Literature
Display
← All papers

Scalable Deep Unfolding of Conic Optimizers

Alex Oshin · Rahul Vodeb Ghosh · Evangelos A. Theodorou

Preprint posted · CoRL 2026 (accepted) ↗

Robotics15 min text · CondensedOriginal paper ↗
Contents

Overview

Code repository. This edition follows the complete twenty-eight-page, 7 November 2026 v2, including the full appendices. The PDF labels the last plot page as Figure 6 continued; the HTML calls it Figure 7. Both plot pages are retained.

At a glance

The paper makes full-update conic-solver iterations trainable at larger scales. A matrix-free adjoint differentiates each linear solve without constructing dense matrix derivatives; a spectral divided-difference rule stabilizes gradients through positive-semidefinite projection. Small learned penalty policies then reduce iterations on seven problem families and accelerate selected planning and batched workloads. Results target moderate accuracy and specific trained families; GPU throughput, solver iteration counts and closed-loop control performance remain distinct measures.

1 Introduction

Deep unfolding retains an optimizer’s update structure while learning components such as initialization and step parameters. It optimizes progress within a finite computation budget rather than learning an arbitrary replacement update. Earlier warm starts, parameter schedules, distributed quadratic solvers and Deep FlexQP motivate the approach.

For large semidefinite programs, dense linear-solve derivatives consume memory and separate eigenvector derivatives become unstable at repeated eigenvalues. The contribution removes these training bottlenecks while retaining full COSMO updates. The reported control experiment solves 16/20 nonlinear covariance-steering scenarios, versus 4/20 baseline COSMO and 12/20 Clarabel; this is simulated optimization/control evidence, not robot-hardware validation.

Complete original PDF block S1.F1
Figure 1: Learned COSMO as the subproblem solver in sequential convex programming (SCP) for nonlinear unicycle covariance steering, over 20 randomized scenarios. A run succeeds when the max SCP residual falls below 10−310^{-3} (dashed), within a budget of 20 SCP iterations and up to 20 s per subproblem solve (dotted, 400 s). Failure modes and closed-loop validation are provided in Appendix H. Clarabel [20] reuses its factorization across SCP iterations. Left: Scenarios solved vs. wall-clock time. Right: Max SCP residual on the 12 scenarios solved by both learned COSMO and Clarabel (a subset of ours; median and IQR). Learned COSMO reaches the threshold in a median of 27.9 s vs. 76.7 s for Clarabel, and is faster on every one of these scenarios.

2 Methodology

The method differentiates two internal operations of COSMO: a quadratic linear-system update and projection onto a product of cones. The rules could apply to related ADMM solvers with the same operations, but the experiments implement COSMO.

2.1 Deep Unfolding Conic Optimization

A convex quadratic objective is constrained by Ax+s=b with slack in a product of nonnegative, second-order and semidefinite cones. Learned maps choose solver parameters and optionally the starting iterate. Training backpropagates through K iterations to improve a trajectory-level loss; it differentiates the algorithm’s finite trajectory, not just its converged optimal solution.

Equations 1–2
minimizex12​x⊤​P​x+q⊤​x,subject​to⁡Ax+s=b,s∈𝒦,\minimize_{x}\hskip 5.0pt\tfrac{1}{2}x^{\top}Px+q^{\top}x,\quad\st\hskip 5.0ptAx+s=b,\hskip 5.0pts\in\mathcal{K}, (1)
minimizeϕ𝔼d∼𝒟​[ℒ⁡(z0,…,zK)].\minimize_{\phi}\hskip 5.0pt\mathbb{E}_{d\sim\mathcal{D}}\big[\,\mathcal{L}(z^{0},\ldots,z^{K})\,\big]. (2)

2.2 Conic Operator Splitting Method (COSMO)

Each COSMO step solves a coupled quadratic system, relaxes the primal/slack iterates, projects the slack and updates the dual. The learned outputs are positive penalties and relaxation in (0,2); σ remains 10⁻⁶. Most operations use ordinary automatic differentiation, while the solve and PSD projection use custom rules. Valid parameter ranges alone do not establish convergence of every arbitrary state-dependent learned schedule.

Equations 3a–3e
[P+σ​IA⊤A−D​(ρk)−1]​[x~k+1ν~k+1]=[σ​xk−qb−sk+yk⊘ρk],\begin{bmatrix}P+\sigma I&A^{\top}\\ A&-D(\rho^{k})^{-1}\end{bmatrix}\begin{bmatrix}\tilde{x}^{k+1}\\ \tilde{\nu}^{k+1}\end{bmatrix}=\begin{bmatrix}\sigma x^{k}-q\\ b-s^{k}+y^{k}\oslash\rho^{k}\end{bmatrix}, (3a)
s~k+1\displaystyle\tilde{s}^{k+1} =sk−(yk+ν~k+1)⊘ρk,\displaystyle=s^{k}-(y^{k}+\tilde{\nu}^{k+1})\oslash\rho^{k}, (3b)
xk+1\displaystyle x^{k+1} =αk​x~k+1+(1−αk)​xk,\displaystyle=\alpha^{k}\tilde{x}^{k+1}+(1-\alpha^{k})x^{k}, (3c)
sk+1\displaystyle s^{k+1} =Π𝒦​(αk​s~k+1+(1−αk)​sk+yk⊘ρk),\displaystyle=\Pi_{\mathcal{K}}(\alpha^{k}\tilde{s}^{k+1}+(1-\alpha^{k})s^{k}+y^{k}\oslash\rho^{k}), (3d)
yk+1\displaystyle y^{k+1} =yk+ρk⊙(αk​s~k+1+(1−αk)​sk−sk+1),\displaystyle=y^{k}+\rho^{k}\odot(\alpha^{k}\tilde{s}^{k+1}+(1-\alpha^{k})s^{k}-s^{k+1}), (3e)

2.3 Matrix-Free Implicit Differentiation

Eliminating the saddle-point multiplier gives a positive-definite system with operator P+σI+AᵀD(ρ)A. Conjugate gradients apply this operator through sparse matrix-vector products. For the backward pass, one adjoint solve with the same operator gives the gradient through its coefficient matrix; the right-hand-side gradient is returned separately so ordinary autograd includes its additional dependence on ρ. Omitting either path would give an incomplete derivative.

The algebra is exact for exact solves; finite forward/adjoint CG tolerances introduce numerical approximation. Avoiding dense AᵀA and its derivative saves memory, but total storage still includes sparse P and A and primal/constraint vectors. O(n+nnz(A)) is not automatically linear in n when sparsity density stays fixed, and runtime also depends on conditioning and CG iterations.

Equations 4–6
(P+σ​I+A⊤​D​(ρk)​A)​x~k+1=σ​xk−q+A⊤​(yk+ρk⊙(b−sk))\big(P+\sigma I+A^{\top}D(\rho^{k})A\big)\tilde{x}^{k+1}=\sigma x^{k}-q+A^{\top}(y^{k}+\rho^{k}\odot(b-s^{k})) (4)
∂ℒ∂ρi=∇x~ℒ⊤​∂x~∂ρi=−∇x~ℒ⊤​M−1​∂M∂ρi​x~=λ~⊤​∂M∂ρi​x~,\partialderivative{\mathcal{L}}{\rho_i}=\nabla_{\tilde{x}}\mathcal{L}^{\top}\partialderivative{\tilde{x}}{\rho_i}=-\nabla_{\tilde{x}}\mathcal{L}^{\top}M^{-1}\partialderivative{M}{\rho_i}\tilde{x}=\tilde{\lambda}^{\top}\partialderivative{M}{\rho_i}\tilde{x}, (5)
∂ℒ∂ρi=(A​λ~)i​(A​x~)i⟹∇ρℒ=(A​λ~)⊙(A​x~).\partialderivative{\mathcal{L}}{\rho_i}=(A\tilde{\lambda})_{i}(A\tilde{x})_{i}\implies\nabla_{\rho}\mathcal{L}=(A\tilde{\lambda})\odot(A\tilde{x}). (6)
Complete original PDF block S2.F2
Figure 2: Backward pass cost of the COSMO linear-system solve as a function of problem size. We differentiate the loss 12​∥x−x⋆∥2\tfrac{1}{2}\lVert x-x^{\star}\rVert^{2} using three methods: autograd through the direct mode Eq. 3a, autograd through the indirect mode Eq. 4 using the approach from Saravanos et al. [42], and our proposed matrix-free rule. Left: Peak GPU memory. Right: Backward wall-clock time, both versus the number of variables nn (with m=n/2m=n/2 constraints), on a single RTX 4090 (24 GB) in float64. Open markers on dashed lines extrapolate methods that exceed the 24 GB budget. Both baselines grow quadratically and exhaust memory by n≈20n\approx 20–5050k, whereas our method scales linearly, staying under 300 MB and remaining the fastest at the largest sizes.
Equations
M​λ~=−∇x~ℒM\tilde{\lambda}=-\nabla_{\tilde{x}}\mathcal{L}
∇ξℒ=M−1​∇x~ℒ=−λ~\nabla_{\xi}\mathcal{L}=M^{-1}\nabla_{\tilde{x}}\mathcal{L}=-\tilde{\lambda}

2.4 Stable PSD Projection

PSD projection clamps negative eigenvalues while preserving eigenvectors. Differentiating eigenvectors separately introduces reciprocal eigenvalue gaps; these can fail numerically even when the composed spectral projection has a well-behaved derivative.

The Dalečkii–Krein matrix-function rule, also used in DeepKSPD, forms divided differences of the clamping function and reuses the forward eigendecomposition. Repeated nonzero eigenvalues have finite limits. At zero the projection is nonsmooth: choosing the ReLU convention f′(0)=0 supplies a backward convention, not a classical Fréchet derivative valid in every perturbation direction.

Equations 7–10
Π𝕊+​(S)=U​max⁡(Λ,0)​U⊤.\Pi_{\mathbb{S}_{+}}(S)=U\max(\Lambda,0)U^{\top}. (7)
S¯=U⁡(Λ¯+F⊙(U⊤​U¯))​U⊤,\bar{S}=U\left(\bar{\Lambda}+F\odot(U^{\top}\bar{U})\right)U^{\top}, (8)
S¯=U⁡(L⊙(U⊤​T¯​U))​U⊤,\bar{S}=U(L\odot(U^{\top}\bar{T}U))U^{\top}, (9)
Li​j={f⁡(λj)−f⁡(λi)λj−λi,λi≠λj,f′​(λi),λi=λj.L_{ij}=\begin{cases}\frac{f(\lambda_{j})-f(\lambda_{i})}{\lambda_{j}-\lambda_{i}},&\lambda_{i}\neq\lambda_{j},\\ f^{\prime}(\lambda_{i}),&\lambda_{i}=\lambda_{j}.\end{cases} (10)
Complete original PDF block S2.F3
Figure 3: PSD-projection gradient along a real ADMM trajectory. We unroll COSMO on a chance-constrained covariance-steering SDP (double-integrator, N=10N=10) from a random initial iterate. As the iterates approach the PSD cone, the minimum eigenvalue gap mini≠j⁡|λi−λj|\min_{i\neq j}\lvert\lambda_{i}-\lambda_{j}\rvert of SkS_{k} (dashed, right axis) falls by over ten orders of magnitude, causing each baseline to eventually fail. Autograd’s error grows as the gap shrinks until it returns NaNs (top band). Denominator regularization is biased whenever the gap drops below ε\varepsilon, so a smaller ε\varepsilon only delays the error. Newton–Schulz produces intermittent error spikes. DK stays at the error floor for the whole trajectory and requires no tuning.

Alternative Approaches.

Denominator regularization avoids division by a zero eigenvalue gap but biases gradients when within-cluster gaps are small. Its zero output at an exact tie does not generally reproduce the DK off-diagonal limit, even as regularization vanishes. Newton–Schulz instead approximates the matrix sign using unrolled products; it avoids explicit reciprocal gaps but costs more and can show error spikes. The figures compare numerical behavior rather than proving universal stability for every finite-precision input.

Equations 11–12
Fi​j=λj−λi(λj−λi)2+ε2,F_{ij}=\frac{\lambda_{j}-\lambda_{i}}{(\lambda_{j}-\lambda_{i})^{2}+\varepsilon^{2}}, (11)
Sk+1=12​Sk​(3​I−Sk2),S0=S/∥S∥F,S_{k+1}=\tfrac{1}{2}S_{k}\big(3I-S_{k}^{2}\big),\qquad S_{0}=S/\lVert S\rVert_{F}, (12)
Complete original PDF block S2.F4
Figure 4: DK is free in the regime where autograd survives. Left: Relative error of each backward rule against a finite-difference reference on matrices of size n=40n=40 with clustered eigenvalues. Autograd remains finite, but is less accurate than DK and Newton–Schulz. Denominator regularization carries a large bias, even when the gap δ≫ε\delta\gg\varepsilon, because the gaps within each cluster (∼10−3​δ\sim 10^{-3}\delta) remain small. Right: Wall-clock time of the backward rule vs. matrix dimension. Autograd, denominator regularization, and DK have comparable costs, whereas Newton–Schulz’s unrolled iterations make it nearly an order of magnitude more expensive.

3 Experiments

A 32×32 residual-conditioned MLP predicts hyperparameters, averaging penalties within each coupled SOC/PSD block. Each family uses about 100 training problems and 100–400 unrolled iterations. The loss sums log normalized primal/dual residual energy, with initial residual denominators detached from gradients.

Constant, adaptive and learned COSMO variants share the authors’ PyTorch implementation and RTX 4090 for the main iteration comparison. Separate CPU package comparisons include implementation/hardware differences. Timings use warm-up and device synchronization on an i9-13900K workstation.

Equation 13
ℒ⁡(z0,…,zK)=∑k=1Klog⁡(∥P​xk+q+A⊤​yk∥2detach⁡(∥P​x0+q+A⊤​y0∥2)+∥A​xk+sk−b∥2detach⁡(∥A​x0+s0−b∥2)),\mathcal{L}(z^{0},\ldots,z^{K})=\sum_{k=1}^{K}\log\left(\frac{\lVert Px^{k}+q+A^{\top}y^{k}\rVert^{2}}{\detach(\lVert Px^{0}+q+A^{\top}y^{0}\rVert^{2})}+\frac{\lVert Ax^{k}+s^{k}-b\rVert^{2}}{\detach(\lVert Ax^{0}+s^{0}-b\rVert^{2})}\right), (13)

3.1 Nonlinear Covariance Steering

Affine disturbance feedback gives a convex covariance-steering subproblem for linear dynamics, following disturbance-feedback control and linear Gaussian covariance control. Nonlinear unicycle dynamics are repeatedly linearized inside SCP.

Unicycle subproblems need a median 63 learned iterations versus 3,954 for tuned constant COSMO, about 63× fewer. That inner-solve ratio differs from the full nonlinear scenario result. On the twelve scenarios solved by both learned COSMO and Clarabel, median total times are 27.9 versus 76.7 seconds, and the learned solver is faster on each; unsuccessful scenarios are excluded from that paired timing subset.

3.2 Benchmark Conic Optimization Problems

The suite includes Lyapunov, max-cut and Lovász SDPs, robust estimation/control SOCPs, and two covariance-steering families. Each main arm has 100 held-out instances, absolute residual tolerance 10⁻³ and a 10,000-iteration/60-second budget.

Learned median iterations are 235, 69, 74, 26, 16, 18 and 63 in Table 1 order, with 100 successes except 99 on unicycle. Thus it improves the tested medians but is not failure-free. Constant/adaptive success varies markedly: Lovász gives 0/77 and unicycle 90/0. Learned robust-KF iteration spread is wider despite a much lower median. The reported 1.3 GB, 29-second-per-epoch unicycle training result concerns the matrix-free implementation on this workload.

Complete original PDF block S3.T1
Table 1: Comparison of COSMO hyperparameter policies on benchmark conic optimization problems. Constant uses the best-tuned fixed values of ρ\rho and α\alpha; Adaptive uses the best-tuned adaptive ρ\rho policy, based on OSQP-style residual balancing; and Learned uses our proposed MLP policies, trained via deep unfolding. We report the median [IQR] of the number of iterations needed to reach an absolute tolerance of ε=10−3\varepsilon=10^{-3} on 100 held-out test instances, along with the number of successful solves. The learned policies outperform both baselines on every problem class.
Original selectable table
Successes (out of 100) Iterations
Problem Class Constant Adaptive Learned Constant Adaptive Learned
Lyapunov LMI 100 47 100 590 [397, 998] 788 [384, 1904] 235 [182, 342]
Max Cut 100 100 100 212 [200, 224] 550 [404, 1034] 69 [65, 79]
Lovász ϑ\vartheta 0 77 100 – 1449 [134, 7848] 74 [69, 81]
Robust KF 100 100 100 314 [312, 317] 314 [312, 317] 26 [24, 32]
Robust MPC 99 100 100 521 [380, 708] 81 [59, 102] 16 [14, 19]
Double Integrator 100 49 100 59 [37, 87] 684 [367, 1534] 18 [10, 31]
Unicycle 90 0 99 3954 [2672, 5306] – 63 [60, 68]

3.3 Batched GPU Throughput

Block-diagonal batching shares one GPU solver run across independent instances. At batch 64, max-cut takes 0.372 seconds versus sequential COSMO.jl’s 3.02; Lovász takes 5.14 versus 72.3, approximately 8.1× and 14.1× throughput gains.

These compare a batched GPU implementation against sequential CPU packages, not identical hardware or a parallel CPU baseline. Ten batches are measured per size. Faster single-instance iteration counts alone do not explain the full throughput advantage.

Complete original PDF block S3.T2
Table 2: Our learned solver (batched, GPU) vs. open-source COSMO.jl v0.8.9 and Clarabel v0.11.1 (sequential, CPU), across varying batch sizes. Ten batches are sampled per size. Median [IQR] of wall-clock times (in seconds) to solve the entire batch.
Original selectable table
Max Cut Lovász ϑ\vartheta
Method B=16B=16 B=64B=64 B=16B=16 B=64B=64
Learned 0.248 [0.232, 0.264] 0.372 [0.361, 0.397] 1.53 [1.21, 2.12] 5.14 [3.65, 8.61]
COSMO.jl 0.721 [0.625, 0.757] 3.02 [2.74, 3.28] 9.63 [9.13, 10.3] 72.3 [39.8, 98.2]
Clarabel 3.70 [3.60, 3.76] 14.9 [14.7, 17.4] 68.6 [68.4, 69.0] 276 [275, 277]

3.4 Out-of-Distribution Generalization

Policies trained at one size are tested on twenty fresh instances at each larger size. Ten times more graph nodes increases max-cut variables from 1,275 to 125,250; longer SOCP horizons instead add similarly sized cone blocks.

All arms finish in this experiment. At 10×, time speedups are 1.76× max-cut, 3.67× robust KF and 2.16× robust MPC, so the abstract’s 2–5× shorthand is not exact for every row. Max-cut transfer also uses a factor-five penalty-adoption gate after updating every iteration caused divergence. Weights are unchanged, but execution policy is modified; the full qualification is retained in Appendix J.

Complete original PDF block S3.T3
Table 3: Out-of-distribution generalization of learned policies trained at 1×1\times and evaluated (without retraining) on new instances 55–10×10\times. Median [IQR] iterations and wall-clock time to ε=10−3\varepsilon=10^{-3} over 20 held-out instances (no arm failed on any instance). Baseline is the best-tuned configuration for non-learned COSMO. Speedup is the median of per-instance baseline // learned ratios.
Original selectable table
Iterations Wall-Clock Time (s) Speedup
Problem Class Size Baseline Learned Baseline Learned Iterations Time
Max Cut n=50n{=}50\hskip 5.0pt (1×1\times) 216 [194, 232] 86 [78, 90] 0.41 [0.36, 0.44] 0.20 [0.18, 0.21] 2.53×2.53\times 2.02×2.02\times
n=250n{=}250 (5×5\times) 432 [420, 437] 204 [192, 214] 2.65 [2.58, 2.68] 1.35 [1.27, 1.42] 2.14×2.14\times 1.96×1.96\times
n=500n{=}500 (10×10\times) 593 [581, 627] 316 [308, 328] 6.66 [6.52, 7.04] 3.85 [3.75, 3.99] 1.91×1.91\times 1.76×1.76\times
Robust KF N=100N{=}100 (1×1\times) 318 [314, 320] 25 [24, 37] 4.72 [4.59, 4.80] 0.84 [0.81, 0.94] 12.5×12.5\times 5.49×5.49\times
N=500N{=}500 (5×5\times) 320 [317, 321] 48 [39, 60] 6.50 [6.37, 6.55] 1.42 [1.33, 1.55] 6.69×6.69\times 4.58×4.58\times
N=1000N{=}1000 (10×10\times) 320 [319, 322] 66 [62, 80] 7.06 [7.03, 7.12] 1.91 [1.82, 2.17] 4.82×4.82\times 3.67×3.67\times
Robust MPC N=50N{=}50 (1×1\times) 66 [52, 91] 16 [14, 17] 0.690 [0.477, 0.881] 0.217 [0.207, 0.233] 4.16×4.16\times 3.16×3.16\times
N=250N{=}250 (5×5\times) 46 [39, 51] 14 [13, 16] 0.536 [0.486, 0.642] 0.214 [0.191, 0.230] 3.31×3.31\times 2.59×2.59\times
N=500N{=}500 (10×10\times) 43 [33, 56] 14 [14, 17] 0.584 [0.387, 0.633] 0.224 [0.208, 0.253] 2.64×2.64\times 2.16×2.16\times

4 Limitations

Dense eigendecomposition of a p×p PSD block still costs O(p³); the stable backward rule does not remove this limit. Benefits depend on sparse problem structure, moderate residual tolerance and amortizing per-family training across many solves. Tight-accuracy superiority over interior-point methods is not claimed.

The study does not establish universal convergence of learned schedules or reliable real-time hardware deployment. Other ADMM solvers, mixed-size training and physical testing remain future work.

Acknowledgments

The authors acknowledge reviewer feedback on the analysis and presentation.

Appendix A Related Work

Learning to optimize and deep unfolding.

LISTA and later algorithm-unrolling work motivate learning within known iterative structure. This provides interpretability and budgeted training, but retaining the update form is not by itself a proof that every learned parameter trajectory inherits the original solver’s guarantees.

Learned QP and conic solvers.

Learned fixed-point warm starts predict initialization; linearized Douglas–Rachford unfolding avoids full inner solves; learned parameter policies adjust the trajectory using current residuals. This paper keeps the full conic update and makes its backward pass tractable.

Differentiable optimization layers.

OptNet and differentiable convex layers differentiate an optimal solution with respect to problem data. A fully converged solution does not depend on algorithmic penalties, so that route does not train their convergence speed. Unrolling exposes finite-iteration behavior; the internal solve still benefits from implicit differentiation.

First-order conic solvers.

SCS, OSQP and COSMO use operator splitting. Indirect solves suit sparse GPU computation, while slow high-accuracy convergence motivates the study’s moderate tolerance. Clarabel supplies a separate interior-point comparison.

Differentiating through eigendecompositions.

Matrix-backpropagation analysis and alternative eigendecomposition gradients explain the repeated-eigenvalue problem. The paper adapts a known spectral derivative to PSD projections inside learned optimization; it does not introduce the general matrix-function theorem.

Appendix B Details on Linear-System Solve Backward Pass Experiment (Figure 2)

The backward benchmark uses n=1,000–50,000, m=n/2, diagonal P and A with 1% density, with 100 random instances per size. Baselines explicitly form dense saddle-point or reduced-system intermediates; open dashed markers extrapolate configurations exceeding the 24 GB limit.

The reported matrix-free peak stays below 300 MB at n=50,000. However, fixed 1% density gives nnz(A)=0.005n²: storage proportional to sparse nonzeros is still quadratic in n for this generator. The advantage is avoiding much larger dense intermediates, not a general linear-in-n bound under fixed density. Dense baselines also do not represent every possible optimized sparse factorization implementation.

Appendix C Details on PSD Projection Backward Pass Experiments (Figures 3 and 4)

One test follows a 100-iteration covariance-steering trajectory with collapsing eigenvalue gaps; ordinary autograd eventually produces NaNs, regularization biases gradients and Newton–Schulz has spikes, while DK remains near the observed error floor.

A controlled test uses forty-dimensional symmetric matrices with clusters centered at ±δ/2 and within-cluster spread 10⁻³δ, over δ=1 to 10⁻¹⁰. Timing sweeps dimensions 10–320 over 100 samples. Newton–Schulz can have lower finite-difference error than DK but is roughly an order of magnitude slower. These two experiments address different regimes; ordinary autograd remains finite in the controlled one.

Equation 14
λi={−δ/2+ui,i=1,…,n/2,+δ/2+ui,i=n/2+1,…,n,ui∼𝒰⁡(−σ,σ).\lambda_{i}=\begin{cases}-\delta/2+u_{i},&i=1,\ldots,n/2,\\ +\delta/2+u_{i},&i=n/2+1,\ldots,n,\end{cases}\quad u_{i}\sim\mathcal{U}(-\sigma,\sigma). (14)

Appendix D Training Details

Each family trains policy and warm-start modules in double precision using Adam, cosine learning rate 10⁻³→10⁻⁴, batch five and gradient clipping 1.0. The lowest validation-loss checkpoint is selected; each model takes under ten GPU hours. Tables 4–5 retain all sizes, 30–100 epochs and 100–400-step unroll horizons.

Jacobi-preconditioned CG uses relative tolerance 10⁻⁸ during training and absolute 10⁻⁴ at inference; the authors report the same ordering across tested inference tolerances. The nonlearned comparisons start from zero. Sparse P storage can be substantial, as the covariance-steering rows show, so total memory is not described by A alone.

Complete original PDF block A4.T4
Table 4: Training and architecture hyperparameters.
Original selectable table
Setting Value
Optimization
Optimizer Adam
Learning rate (cosine schedule) 10−3→10−410^{-3}\rightarrow 10^{-4}
Super-batch size BB 5
Gradient-norm clip 1.0
Train / validation instances 100 / 20
Solver
Linear solve CG & Jacobi preconditioner
PSD-projection backward DK rule
Hyperparameter policy (πϕ\pi_{\phi})
Hidden layers (ReLU MLP) 32×3232\times 32
Penalty bounds [ρmin,ρmax][\rho_{\min},\rho_{\max}] [10−3,103][10^{-3},10^{3}]
Initial (ρeq,ρineq,ρsoc,ρpsd)(\rho_{\mathrm{eq}},\rho_{\mathrm{ineq}},\rho_{\mathrm{soc}},\rho_{\mathrm{psd}}) (100,0.1,0.1,0.1)(100,0.1,0.1,0.1)
Initial α\alpha 1.6
Warm-start network
Hidden layers (ReLU MLP) 64×6464\times 64
Complete original PDF block A4.T5
Table 5: Per-instance problem sizes and per-class training settings. nn and mm are the number of variables and constraints of a single instance, and nnz⁡(P)\mathrm{nnz}(P) and nnz⁡(A)\mathrm{nnz}(A) are the number of nonzeros in the cost and constraint matrices. KK is the number of unrolled COSMO iterations during training.
Original selectable table
Problem Variables nn Constraints mm nnz⁡(P)\mathrm{nnz}(P) nnz⁡(A)\mathrm{nnz}(A) Unroll KK Epochs
Lyapunov LMI 820 1640 0 64040 400 30
Max Cut 1275 1325 0 1325 300 60
Lovász ϑ\vartheta 5050 7444–7567 0 7543–7666 100 50
Robust KF 1204 1200 300 2700 100 100
Robust MPC 507 1425 456 4125 300 60
Double Integrator 3904 8363 68624 8052 150 60
Unicycle 2943 4861 100203 7200 150 60

Appendix E Policy Parameterization

Hyperparameter policy.

Shared residual-conditioned MLPs update logits recurrently. Squashed outputs keep penalties between 10⁻³ and 10³ and relaxation between zero and two. Features combine normalized global KKT residuals with local slack changes and projection mismatch; all exact feature formulas remain available.

Zero-initialized output layers begin at constant COSMO parameters, with learnable initial logits. Averaging within each nonseparable cone supplies one scalar penalty for its ordinary Euclidean projection. Per-row penalties remain for zero/nonnegative cones. The bounds and initialization improve training behavior but do not supply a general convergence theorem.

Equations
ρk=exp⁡((log⁡ρmax−log⁡ρmin)​σ​(ℓρk)+log⁡ρmin)∈(ρmin,ρmax),αk=2​σ​(ℓαk)∈(0,2),\rho^{k}=\exp((\log\rho_{\max} - \log\rho_{\min}) \sigma(\ell_\rho^k) + \log\rho_{\min})\in(\rho_{\min},\rho_{\max}),\quad\alpha^{k}=2\sigma(\ell_{\alpha}^{k})\in(0,2),
ℓρk+1\displaystyle\ell_{\rho}^{k+1} =ℓρk+Δℓρk,Δℓρk=MLPρ(ξρk),\displaystyle=\ell_{\rho}^{k}+\Delta\ell_{\rho}^{k},\quad\Delta\ell_{\rho}^{k}=\mathrm{MLP}_{\rho}(\xi_{\rho}^{k}),
ℓαk+1\displaystyle\ell_{\alpha}^{k+1} =ℓαk+Δℓαk,Δℓαk=MLPα(ξαk).\displaystyle=\ell_{\alpha}^{k}+\Delta\ell_{\alpha}^{k},\quad\Delta\ell_{\alpha}^{k}=\mathrm{MLP}_{\alpha}(\xi_{\alpha}^{k}).
rdk=P​xk+q+A⊤​ykmax⁡(∥P​xk∥∞,∥q∥∞,∥A⊤​yk∥∞)∈ℝn,rpk=A​xk+sk−bmax⁡(∥A​xk∥∞,∥sk∥∞,∥b∥∞)∈ℝm.r_{d}^{k}=\frac{Px^{k}+q+A^{\top}y^{k}}{\max\left(\lVert Px^{k}\rVert_{\infty},\lVert q\rVert_{\infty},\lVert A^{\top}y^{k}\rVert_{\infty}\right)}\in\mathbb{R}^{n},\quad r_{p}^{k}=\frac{Ax^{k}+s^{k}-b}{\max\left(\lVert Ax^{k}\rVert_{\infty},\lVert s^{k}\rVert_{\infty},\lVert b\rVert_{\infty}\right)}\in\mathbb{R}^{m}.
δdk=sk−sk−1,δpk=sk−s~k.\delta_{d}^{k}=s^{k}-s^{k-1},\quad\delta_{p}^{k}=s^{k}-\tilde{s}^{k}.
ξρ,ik=[ℓρ,iksikyikrp,iklog⁡(∥rdk∥∞+ϵ)δp,ikδd,ik],ξαk=[ℓαklog⁡(∥rpk∥∞+ϵ)log⁡(∥rdk∥∞+ϵ)log⁡(∥δpk∥∞+ϵ)log⁡(∥δdk∥∞+ϵ)],\xi_{\rho,i}^{k}=\begin{bmatrix}\ell_{\rho,i}^{k}\\ s_{i}^{k}\\ y_{i}^{k}\\ r_{p,i}^{k}\\ \log(\norm{r_{d}^k}_\infty+ \epsilon)\\ \delta_{p,i}^{k}\\ \delta_{d,i}^{k}\end{bmatrix},\quad\xi_{\alpha}^{k}=\begin{bmatrix}\ell_{\alpha}^{k}\\ \log(\norm{r_{p}^k}_\infty+ \epsilon)\\ \log(\norm{r_{d}^k}_\infty+ \epsilon)\\ \log(\norm{\delta_p^k}_\infty+ \epsilon)\\ \log(\norm{\delta_d^k}_\infty+ \epsilon)\end{bmatrix},

Warm-start network.

Two shared 64×64 MLPs predict variable and constraint initialization from local cost/matrix statistics, cone type and pooled scale/size features. Zero output initialization recovers the baseline zero iterate and allows the same weights to accept different problem sizes.

Figure 5 attributes most gains to the adaptive policy: warm starts can hurt robust MPC, and joint training offers little extra over the policy alone. The benchmark descriptions nevertheless specify policy plus warm-start modules for the learned arm. Figures 6 and its continuation preserve every problem-family penalty/relaxation plot; cone-specific penalties differ from a scalar residual-balancing rule.

Complete original PDF block A5.F5
Figure 5: Ablation study comparing the residual convergence of COSMO vs. the proposed learned variants. On nearly all of the problem classes, the learned policy exhibits the best performance. The warm start generally delivers an improvement over vanilla COSMO, but occasionally hurts performance, such as on the robust MPC problems. Learning both the policy and warm start jointly does not seem to improve performance over learning the policy alone, so we conclude that most of the performance gain can be attributed to the policy.
Complete original PDF block A5.F6
Figure 6: Median and IQR hyperparameter predictions per cone type, with statistics taken over 100 problems. We compare the baseline OSQP residual-balancing rule (left) vs. our learned policy (center, right) on all problem classes (rows). The baseline maintains a single scalar ρ\rho that is scaled by 10310^{3} for equality constraints [44], and uses a fixed α=1.6\alpha=1.6, denoted by the dashed line on the rightmost plot. The left and center plots share y-axes.
Complete original PDF block A5.F7
Figure 7: Hyperparameter predictions per cone type (continued).

Appendix F Conic Optimization Problems

Unless stated otherwise, datasets use 100 training, twenty validation and 100 independently seeded test problems per family. The complete conic formulations and generator settings follow; generated distributions and filtering are part of the benchmark scope.

F.1 Covariance Steering

Stacked linear dynamics and strictly causal disturbance feedback U=KW+V separate mean control from covariance shaping. Covariance upper bounds become Schur-complement LMIs, retaining a convex formulation rather than a nonconvex low-rank factorization.

For nonlinear dynamics, SCP linearizes around a reference, adds penalized virtual control to mean dynamics and accepts steps using a trust-region ratio. Virtual control relaxes those dynamics; it does not by itself guarantee feasibility of every covariance, boundary or trust-region constraint.

Double-integrator instances use horizon thirty, step 0.5, random target position and the stated diagonal process-noise covariance. Unicycle uses horizon thirty, step 0.1, randomized heading/targets/covariance bounds and virtual-control weight 10⁴. The paper’s exact covariance choices are preserved rather than silently replacing them with a different continuous-noise discretization.

For unicycle training, twelve scenarios generate ten Clarabel subproblems each: ten scenarios supply 100 training subproblems and two supply twenty validation subproblems. Ten independent scenarios supply the standalone test set; twenty further scenarios evaluate full SCP. Correlated subproblems within one scenario are not independent original planning problems.

Equations
xt+1=f⁡(xt,ut)+wt,wt∼𝒩⁡(0,Wt),x0∼𝒩⁡(μ0,Σ0),x_{t+1}=f(x_{t},u_{t})+w_{t},\quad w_{t}\sim\mathcal{N}(0,W_{t}),\quad x_{0}\sim\mathcal{N}(\mu_{0},\Sigma_{0}),
xt=Φ⁡(t,0)​x0+∑τ=0t−1Φ⁡(t,τ+1)​(Bτ​uτ+rτ+wτ),x_{t}=\Phi(t,0)\,x_{0}+\sum_{\tau=0}^{t-1}\Phi(t,\tau+1)\left(B_{\tau}u_{\tau}+r_{\tau}+w_{\tau}\right),
X=A¯​x0+B¯​U+D¯​W+r¯,X=\bar{A}x_{0}+\bar{B}U+\bar{D}W+\bar{r},
A¯=[IΦ⁡(1,0)⋮Φ⁡(N,0)],B¯=[00⋯0Φ⁡(1,1)​B00⋯0Φ⁡(2,1)​B0Φ⁡(2,2)​B1⋯0⋮⋮⋱⋮Φ⁡(N,1)​B0Φ⁡(N,2)​B1⋯Φ⁡(N,N)​BN−1].\bar{A}=\begin{bmatrix}I\\ \Phi(1,0)\\ \vdots\\ \Phi(N,0)\end{bmatrix},\qquad\bar{B}=\begin{bmatrix}0&0&\cdots&0\\ \Phi(1,1)B_{0}&0&\cdots&0\\ \Phi(2,1)B_{0}&\Phi(2,2)B_{1}&\cdots&0\\ \vdots&\vdots&\ddots&\vdots\\ \Phi(N,1)B_{0}&\Phi(N,2)B_{1}&\cdots&\Phi(N,N)B_{N-1}\end{bmatrix}.
U=K​W+V,U=KW+V,
μt=A¯t​μ0+B¯t​V+r¯t,Σt=A¯t​Σ0​A¯t⊤+(D¯t+B¯t​K)​ΣW​(D¯t+B¯t​K)⊤,\mu_{t}=\bar{A}_{t}\mu_{0}+\bar{B}_{t}V+\bar{r}_{t},\qquad\Sigma_{t}=\bar{A}_{t}\Sigma_{0}\bar{A}_{t}^{\top}+(\bar{D}_{t}+\bar{B}_{t}K)\Sigma_{W}(\bar{D}_{t}+\bar{B}_{t}K)^{\top},
[M−A¯t​Σ0​A¯t⊤(D¯t+B¯t​K)​ΣW1/2ΣW1/2⊤​(D¯t+B¯t​K)⊤I]⪰0.\begin{bmatrix}M-\bar{A}_{t}\Sigma_{0}\bar{A}_{t}^{\top}&(\bar{D}_{t}+\bar{B}_{t}K)\Sigma_{W}^{1/2}\\ \Sigma_{W}^{1/2\top}(\bar{D}_{t}+\bar{B}_{t}K)^{\top}&I\end{bmatrix}\succeq 0.
minimizeμ,V,K,ν\displaystyle\minimize_{\mu,V,K,\nu} ∑t=0N−1(𝔼⁡[xt⊤​Q​xt]+𝔼⁡[ut⊤​R​ut]+λν​∥νt∥1)+𝔼⁡[xN⊤​QN​xN],\displaystyle\sum_{t=0}^{N-1}\left(\mathbb{E}[x_{t}^{\top}Qx_{t}]+\mathbb{E}[u_{t}^{\top}Ru_{t}]+\lambda_{\nu}\lVert\nu_{t}\rVert_{1}\right)+\mathbb{E}[x_{N}^{\top}Q_{N}x_{N}],
subject​to\displaystyle\st μt+1=At​μt+Bt​vt+rt+νt,\displaystyle\mu_{t+1}=A_{t}\mu_{t}+B_{t}v_{t}+r_{t}+\nu_{t},
μ0=μ¯0,μN=μgoal,\displaystyle\mu_{0}=\bar{\mu}_{0},\quad\mu_{N}=\mu_{\text{goal}},
Σt⪯Σmax,ΣN⪯ΣNdes,\displaystyle\Sigma_{t}\preceq\Sigma_{\text{max}},\quad\Sigma_{N}\preceq\Sigma_{N}^{\text{des}},
∥μt−μtref∥2≤ρx,∥vt−vtref∥2≤ρu,\displaystyle\lVert\mu_{t}-\mu_{t}^{\text{ref}}\rVert_{2}\leq\rho_{x},\quad\lVert v_{t}-v_{t}^{\text{ref}}\rVert_{2}\leq\rho_{u},
A=[I2Δ​t​I20I2],B=[12​Δ​t2​I2Δ​t​I2],W=diag⁡(Δ​t33​σa2​I2,Δ​t​σa2​I2),A=\begin{bmatrix}I_{2}&\Delta t\,I_{2}\\ 0&I_{2}\end{bmatrix},\quad B=\begin{bmatrix}\tfrac{1}{2}\Delta t^{2}I_{2}\\ \Delta t\,I_{2}\end{bmatrix},\quad W=\diag\!\left(\tfrac{\Delta t^{3}}{3}\sigma_{a}^{2}I_{2},\ \Delta t\,\sigma_{a}^{2}I_{2}\right),
x˙=f⁡(x,u)=[v​cos⁡θv​sin⁡θω].\dot{x}=f(x,u)=\begin{bmatrix}v\cos\theta\\ v\sin\theta\\ \omega\end{bmatrix}.

F.2 Lyapunov Linear Matrix Inequality

A forty-state stable linear system supplies a minimum-trace Lyapunov SDP with AᵀP+PA≼−I and P≽I. Two equally likely generators vary nonnormal upper-triangular dynamics or damped oscillator blocks under orthogonal transforms. Cases with spectral abscissa not below −0.05 are resampled. The trace objective normalizes the selected certificate; the notes do not assume strict convexity or uniqueness from a linear objective alone.

Equations
minimizeP∈𝕊n\displaystyle\minimize_{P\in\mathbb{S}^{n}} tr⁡(P),\displaystyle\tr(P),
subject​to\displaystyle\st A⊤​P+P​A⪯−I,\displaystyle A^{\top}P+PA\preceq-I,
P⪰I.\displaystyle P\succeq I.
Ri=[−ζi​ωiωi−ωi−ζi​ωi],R_{i}=\begin{bmatrix}-\zeta_{i}\omega_{i}&\omega_{i}\\ -\omega_{i}&-\zeta_{i}\omega_{i}\end{bmatrix},

F.3 Max Cut

The standard max-cut SDP maximizes one quarter of the Laplacian inner product subject to unit diagonal and PSD X, following Goemans–Williamson. Training graphs have fifty nodes and edge probability 0.5. Solver speed is measured on the relaxation, not on a rounded discrete cut or its approximation quality.

Equation
maximizeX∈𝕊n\displaystyle\maximize_{X\in\mathbb{S}^{n}} 14​⟨L,X⟩,\displaystyle\frac{1}{4}\langle L,X\rangle,
subject​to\displaystyle\st Xi​i=1,∀i=1,…,n,\displaystyle X_{ii}=1,\quad\forall i=1,\ldots,n,
X⪰0.\displaystyle X\succeq 0.

F.4 Lovász ϑ

The Lovász theta SDP maximizes the all-ones inner product with trace one, zero edge entries and PSD X. Erdős–Rényi training graphs have one hundred nodes and edge probability 0.5. This is a different graph relaxation from max-cut despite shared PSD machinery.

Equation
maximizeX∈𝕊n\displaystyle\maximize_{X\in\mathbb{S}^{n}} ⟨J,X⟩,\displaystyle\langle J,X\rangle,
subject​to\displaystyle\st tr⁡(X)=1,\displaystyle\tr(X)=1,
Xi​j=0,∀(i,j)∈E,\displaystyle X_{ij}=0,\quad\forall(i,j)\in E,
X⪰0,\displaystyle X\succeq 0,

F.5 Robust Kalman Filter

The robust estimation SOCP fits a dragged double-integrator trajectory using quadratic process-noise cost and Huber observation residuals, adapted from the CVXPY example. Horizon is one hundred, step 0.1, drag 0.05 and both Huber parameters are two. Observations use an 80% unit-noise/20% standard-deviation-twenty mixture. It is a batch trajectory-estimation benchmark, not a measured online filter on a physical sensor.

Equations
minimize\displaystyle\minimize ∑t=0N−1(∥wt∥22+τ​ϕδ​(vt)),\displaystyle\sum_{t=0}^{N-1}\left(\lVert w_{t}\rVert_{2}^{2}+\tau\phi_{\delta}(v_{t})\right),
subject​to\displaystyle\st xt+1=A​xt+B​wt,\displaystyle x_{t+1}=Ax_{t}+Bw_{t},
yt=C​xt+vt,\displaystyle y_{t}=Cx_{t}+v_{t},
ϕδ​(v)={∥v∥22if​∥v∥2≤δ,δ⁡(2​∥v∥2−δ)if​∥v∥2>δ.\phi_{\delta}(v)=\begin{cases}\lVert v\rVert_{2}^{2}&\text{if}\ \lVert v\rVert_{2}\leq\delta,\\ \delta(2\lVert v\rVert_{2}-\delta)&\text{if}\ \lVert v\rVert_{2}>\delta.\end{cases}
A=[10(1−12​γ​Δ​t)​Δ​t0010(1−12​γ​Δ​t)​Δ​t001−γ​Δ​t00001−γ​Δ​t],B=[12​Δ​t20012​Δ​t2Δ​t00Δ​t],C=[10000100],A=\begin{bmatrix}1&0&(1-\tfrac{1}{2}\gamma\Delta t)\Delta t&0\\ 0&1&0&(1-\tfrac{1}{2}\gamma\Delta t)\Delta t\\ 0&0&1-\gamma\Delta t&0\\ 0&0&0&1-\gamma\Delta t\end{bmatrix},\quad B=\begin{bmatrix}\tfrac{1}{2}\Delta t^{2}&0\\ 0&\tfrac{1}{2}\Delta t^{2}\\ \Delta t&0\\ 0&\Delta t\end{bmatrix},\quad C=\begin{bmatrix}1&0&0&0\\ 0&1&0&0\end{bmatrix},
vt∼{𝒩⁡(0,I)with probability​p=0.8,𝒩⁡(0,σoutlier2​I)otherwise,v_{t}\sim\begin{cases}\mathcal{N}(0,I)&\text{with probability}\ p=0.8,\\ \mathcal{N}(0,\sigma_{\text{outlier}}^{2}I)&\text{otherwise},\end{cases}

F.6 Robust Model Predictive Control

The MPC benchmark uses nominal linear dynamics, covariance-based half-space tightening, control-norm epigraph costs and a penalized terminal distance. It models three spring-coupled masses with six states/three inputs, horizon fifty and step 0.2. State boxes are position ±5 and velocity ±1; input bounds are ±0.5. Disturbance scale is 0.01 and κ=2.

The description calls the formulation robust to every bounded ellipsoidal disturbance. Its covariance recursion and root-sum-square tightening do not generally give that worst-case guarantee over independently bounded disturbances; such reachable-set support radii accumulate as a sum. Appendix H instead samples unbounded Gaussian disturbances. The formulas and observed outcomes remain, without promoting the label to a universal safety certificate.

About 10% of candidate initial states/penalties are rejected if Clarabel finds infeasibility or an optimal dual norm above 150. This filters the evaluation distribution. The terminal target is softly penalized through an epigraph, not enforced as a hard equality.

Equations
minimize\displaystyle\minimize ∑t=0N−1(xt⊤​Q​xt+ut⊤​R​ut+γ​τt)+xN⊤​QN​xN+γterm​τterm,\displaystyle\sum_{t=0}^{N-1}(x_{t}^{\top}Qx_{t}+u_{t}^{\top}Ru_{t}+\gamma\tau_{t})+x_{N}^{\top}Q_{N}x_{N}+\gamma_{\text{term}}\tau_{\text{term}},
subject​to\displaystyle\st xt+1=A​xt+B​ut,\displaystyle x_{t+1}=Ax_{t}+Bu_{t},
x0=xinit,\displaystyle x_{0}=x_{\text{init}},
Ax​xt≤bx−κ​dt,\displaystyle A_{x}x_{t}\leq b_{x}-\kappa d_{t},
Au​ut≤bu,\displaystyle A_{u}u_{t}\leq b_{u},
∥ut∥2≤τt,\displaystyle\lVert u_{t}\rVert_{2}\leq\tau_{t},
∥xN−xtarget∥2≤τterm,\displaystyle\lVert x_{N}-x_{\text{target}}\rVert_{2}\leq\tau_{\text{term}},
x˙=[0I3−K−c​I3]​x+[0I3]​u,K=k​[2−10−12−10−11],\dot{x}=\begin{bmatrix}0&I_{3}\\ -K&-cI_{3}\end{bmatrix}x+\begin{bmatrix}0\\ I_{3}\end{bmatrix}u,\qquad K=k\begin{bmatrix}2&-1&0\\ -1&2&-1\\ 0&-1&1\end{bmatrix},
Σt+1=A​Σt​A⊤+Σw\Sigma_{t+1}=A\Sigma_{t}A^{\top}+\Sigma_{w}
ai⊤​x≤bi−κ​∥Σt1/2​ai∥2a_{i}^{\top}x\leq b_{i}-\kappa\lVert\Sigma_{t}^{1/2}a_{i}\rVert_{2}

Appendix G Additional Benchmarks

CPU COSMO.jl and Clarabel use eight BLAS threads, warm-up and 10⁻³ tolerances; chordal decomposition is disabled. COSMO.jl otherwise retains scaling, adaptive penalties and Anderson acceleration, while Clarabel retains presolve/equilibration.

Learned GPU COSMO is fastest for Lovász and both covariance-steering classes. COSMO.jl is faster on Lyapunov and max-cut, and Clarabel is much faster on the small robust-KF/MPC SOCPs: learned/Clarabel medians are 0.884/0.00208 seconds and 0.216/0.00193 seconds. These results qualify any claim of universal wall-clock superiority, and disabling decomposition limits the comparison with fully configured sparse SDP packages.

Complete original PDF block A7.T6
Table 6: Median [IQR] wall-clock time per instance (in seconds), over 100 held-out test instances. Each solver uses a convergence tolerance of 10−310^{-3}. Constant, Adaptive, and Learned use our PyTorch reimplementation of COSMO with the corresponding policies from Table 1.
Original selectable table
Problem Class Constant Adaptive Learned COSMO.jl Clarabel
Lyapunov LMI 1.58 [1.04, 3.11] 2.42 [1.26, 5.39] 1.09 [0.761, 1.52] 0.462 [0.398, 0.590] 0.593 [0.519, 0.721]
Max Cut 0.396 [0.376, 0.421] 1.08 [0.788, 2.01] 0.159 [0.149, 0.179] 0.0411 [0.0382, 0.0492] 0.229 [0.205, 0.239]
Lovász ϑ\vartheta – 1.01 [0.547, 12.2] 0.359 [0.333, 0.391] 0.599 [0.523, 0.773] 4.27 [4.23, 4.31]
Robust KF 4.62 [4.50, 4.75] 4.64 [4.52, 4.79] 0.884 [0.831, 0.966] 0.0169 [0.0167, 0.0171] 0.00208 [0.00205, 0.00213]
Robust MPC 1.02 [0.842, 1.35] 0.821 [0.633, 1.02] 0.216 [0.196, 0.248] 0.0137 [0.0134, 0.0154] 0.00193 [0.00173, 0.00195]
Double Integrator 0.971 [0.531, 1.57] 4.81 [3.03, 9.20] 0.633 [0.428, 0.734] 2.73 [2.53, 2.95] 14.1 [12.8, 14.5]
Unicycle 31.4 [21.3, 40.9] – 0.911 [0.808, 0.992] 1.48 [1.22, 2.16] 3.82 [3.53, 3.98]

Appendix H Control Performance and Failure Modes

This appendix checks control outcomes beyond solver residuals. Results are simulated and conditional on the returned solutions; both incomplete inner solves and failures of the outer planning loop matter.

Failure modes for nonlinear covariance steering.

Each nonlinear scenario has twenty SCP steps and up to twenty seconds per subproblem. Learned COSMO fails four scenarios: two finish near residual 0.0033, and two stall at 0.29/0.99 despite later inner solves converging. Clarabel fails eight: five repeatedly return no solution, three stall despite solved subproblems.

Clarabel fails on all four scenarios failed by the learned solver. Conversely, learned COSMO succeeds on three scenarios containing timed-out inner solves. Inner residual convergence and full nonlinear planning success are therefore related but not interchangeable.

Monte Carlo validation of the covariance bounds.

For each successfully solved unicycle scenario, 2,000 shared-noise rollouts test the affine disturbance-feedback policy on the nonlinear Euler dynamics. Empirical terminal covariance stays below its target, with largest-eigenvalue margins from −0.05 to −0.00051; terminal mean error is at most 0.0071. Median empirical/predicted cost ratios are 1.0006 learned and 1.0003 Clarabel.

This validates the reported successful scenarios under sampled disturbances. It does not cover failed scenarios or prove a population covariance bound from finite Monte Carlo samples.

Closed-loop robust MPC.

Ten fifty-step closed-loop MPC episodes use Gaussian process noise. On nine episodes, all methods converge at every step without state violations; learned cost nearly matches Clarabel. Learned median time is 0.29 seconds versus adaptive COSMO 2.10 and CPU Clarabel 0.035, so even the learned median exceeds the model’s 0.2-second sampling interval.

On the remaining episode all methods fail early. Learned COSMO and Clarabel apply zero after nonfinite/no solutions and violate the state box on four steps by up to 0.42; adaptive COSMO applies inexact iterates and violates three steps by up to 0.08. A returned approximate iterate or zero-control fallback is not certified safe, and the reported failures remain visible.

Appendix I Details on Batched Solve Experiment (Table 2)

Instances.

Fresh, nonrepeated batches of 8/16/32/64 graphs use the same distribution as training-size test data. Ten batches per size share instances across solvers. Relative throughput grows with batch size; Table 2 displays the sixteen- and sixty-four-instance cases.

Learned solver.

The learned arm batches sparse operators, cone projections and policy evaluation. It stops only once every instance meets tolerance; already converged instances keep iterating, so slower members control batch duration. Median Lovász batch iterations rise from 154 to 434 as batch size grows from eight to sixty-four. All tested batches finish within 10,000 iterations/60 seconds.

Timing.

GPU timing includes batch assembly and solver construction, reported as 1–3% of total, after warm-up absorbs initialization. CPU totals sum each package’s native sequential solve/setup times. CUDA synchronization is explicit; this benchmark concerns throughput under those implementations, not a hardware-neutral algorithmic ratio.

Appendix J Details on Out-of-Distribution Experiment (Table 3)

Instances.

Scaling graph nodes increases the max-cut PSD block from 50×50 to 500×500, whereas scaling KF/MPC horizons adds fixed-size SOC blocks. Twenty instances per size use unchanged generator parameters; these are new samples, so the 1× statistics differ from Table 1.

Arms.

Row-wise shared features let trained policy/warm-start weights accept new sizes. SOCP penalties update every iteration. Max-cut instead adopts a predicted penalty only after a factor-five change because unrestricted updates diverged under shifted residual scales.

The baseline is the adaptive residual-balancing arm with the same gate and zero initialization; tuned constants are omitted because they are training-size-specific. Thus “best-tuned baseline” in the table caption should be read in light of this narrower protocol. No retraining does not mean every inference setting is unchanged.

Protocol.

Every size uses residual tolerance 10⁻³ and a 10,000-iteration/600-second cap; neither arm fails. Speedups are medians of paired instance ratios, which need not equal ratios of the displayed median times. Robust-KF iteration growth reflects shifted difficulty, robust-MPC baseline iterations decrease with horizon, and max-cut gets harder for both arms.

Concept demonstration

Open image ↗