acceptodds
Under review as a conference paper at ICLR 2027

FlexCone: An Always-Feasible First-Order Solver for Conic Optimization

Abstract

Conic subproblems produced by linearization or convexification, as in sequential convex programming (SCP) and related methods, are frequently infeasible, even when the original nonlinear constraints are satisfiable. Existing solvers certify such infeasibility but return nothing to act on, so controllers fall back on stale solutions that violate constraints. We propose FlexCone, an always-feasible first-order conic solver that handles feasible and infeasible problems within a single framework. FlexCone applies ADMM to an exact relaxation of the conic program that provably recovers the original solution when the problem is feasible and converges to a minimum-violation point when it is not. Because every instance runs the same operations, FlexCone batches efficiently on a GPU and can be trained using deep unfolding. On standard convex benchmarks, learned FlexCone matches or improves upon learned projection-based solvers. In closed-loop model predictive control, it is competitive on feasible subproblems and recovers from infeasible ones, eliminating the constraint violations and collisions of the standard fallback. On neural network robustness certification, where infeasibility of an LP relaxation certifies robustness, our batched solver returns certificates orders of magnitude faster than baseline solvers on the same formulations.

Primary area:
optimization
Keywords:
conic optimization, first-order optimization, sequential convex programming, deep unfolding

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_z4m6OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

FlexCone replaces hard cone constraints with blockwise cone-distance penalties based on the type of cones, and applies an ADMM splitting in which the cone projection becomes a proximal update. For infeasible problems, the penalized solution trades objective value against constraint violation; scaling the penalties drives the violation toward its minimum. The method also keeps its updated dual iterates bounded, and supports learned warm starts and algorithm parameters through unrolling.

Critical strengths
  • The conic distance penalty gives a clean way to return useful points when subproblems are infeasible, without enlarging the optimization problem.
  • The applications show practical benefits in extended numerical experiments, supported by a clear analysis of the penalized solver.
Critical weaknesses
  • The experiments rely heavily on COSMO variants. Comparisons with a broader range of methods for handling infeasible conic subproblems would make the practical advantage more convincing. The benefit of the learned policy on infeasible instances also remains unclear.
  • The residual discussion incorrectly equates satisfaction of the penalized KKT conditions with zero original-cone violation. This matters precisely in the infeasible regime the paper aims to address.

Minor concerns: the assumptions should distinguish Slater's condition from primal attainment: Slater alone does not guarantee that an optimizer, and hence a KKT point, exists. It only guarantees strong duality/KKT when a finite optimal value exists.

Questions for authors
  • Could the authors compare FlexCone with an existing conic PDHG solver on the original feasible problems, at matched accuracy and hardware?
  • On infeasible control subproblems, could they also compare against an elastic PDHG formulation under the same SCP loop and fallback policy?
1 comment
AuthorsOpenReview ↗

Response to Reviewer z4m6

We thank the reviewer for the constructive feedback and for suggesting the PDHG comparisons, which we have now run.

W1 / Q1 - Conic PDHG on the feasible benchmarks

We benchmarked against PDCS and PDHCG, two GPU conic PDHG solvers, on the the same 20 instance benchmark as in Table 2. PDCS only supports second-order cones, so it was only run on the robust MPC and robust KF classes below. We also benchmarked against an interior-point method Clarabel for reference.

Median wall-clock time (s):

ClassCOSMOFlexConeLearned FlexConePDCSPDHCGClarabel
Max-cut (SDP)1.761.600.23-0.480.23
Lovász ϑ\vartheta (SDP)0.320.480.28-1.414.27
Robust MPC (SOCP)2.312.240.491.280.040.00193
Robust KF (SOCP)10.94.132.351.560.120.00208
CS double integrator (SDP)32.419.31.66-16.814.1
CS unicycle (SDP)6001140.70-11.43.82

Learned FlexCone still provides a substantial benefit on the SDP classes and is 2-16$\times$ faster than PDHCG. Meanwhile, PDHCG and Clarabel are much faster on the small SOCPs. We have added these additonal benchmarks in the updated appendix.

W1 / Q2 - Elastic baselines in the SCP loop

We re-ran the closed-loop control experiments using COSMO, Clarabel, and PDHCG with an explicit ℓ1\ell_1 slack formulation. PDHCG receives the same per-step compute as FlexCone and COSMO.

3-DoF powered descent:

MethodSuccesses (out of 60)Median / p90 time per subproblem (s)Median / p90 time to success (s)
FlexCone (re-measured)54 (90%)0.101 / 0.32510.1 / 19.0
COSMO slacks0 (0%)0.155 / 2.68N/A
Clarabel slacks8 (13%)0.020 / 0.0342.9 / 3.0
PDHCG slacks2 (3%)1.14 / 3.4765 / 75

Iterative covariance steering:

MethodSuccesses (out of 60)Median / p90 time per subproblem (s)Median / p90 time to success (s)
FlexCone (re-measured)52 (87%)0.47 / 3.67150 / 223
COSMO slacks58 (97%)2.1 / 40.81420 / 1780
Clarabel slacks60 (100%)10.5 / 12.8921 / 944
PDHCG slacks24 (40%)15.7 / 45.11790 / 2170

On powered descent, while Clarabel is the fastest solver overall, all the slack baselines have limited successes. Meanwhile, on iterative covariance steering, FlexCone achieves an 87% success rate with the fastest subproblem time and time to success. COSMO slacks and Clarabel slacks achieve high success rates but suffer from a slow solve time due to the size of the SDP subproblems. These results further support our claim that FlexCone provides a unique capability over existing/standard techniques.

W1 - Benefit of the learned policy on infeasible instances

We trained a policy on a 50/50 mix of feasible and infeasible certification systems and tested it on 388 held-out infeasible systems. At 300 iterations it brings 97.7% of them to within 1% of the minimum violation, against 89.2% for the best fixed setting. It reduces iterations to a certification verdict by about 1.2$\times$. However, it is about 4.5$\times$ slower in total wall-clock time, because it changes the step size at every iteration. We report this as a mixed result: the policy reduces iterations on infeasible instances but it does not yet reduce time.

W2 - Penalized KKT conditions and original-cone violation

The reviewer is correct. The sentence in Section 2.4 stating that the residual vanishes exactly at a penalized KKT point is wrong, since it includes the original cone violation. Satisfying the penalized conditions (Proposition 2.2) implies zero original-cone violation only when the problem is feasible and μ\mu is large enough (Theorem 2.3). On an infeasible problem, the cone violation at the penalized solution is positive by construction. Our implementation applies the cone-violation term to feasible instances, and on infeasible instances the loss uses only the stationarity and penalized complementarity terms. We have corrected the text to match.

Minor: Slater's condition and attainment

We agree. We replaced the assumption with "the optimal value is finite and attained and a constraint qualification holds, so that a KKT point exists". Theorem 2.3a is already stated for a given KKT point and is unaffected.

Reviewer_jNTfOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

FlexCone replaces each conic constraint b_i − A_i x ∈ K_i with an exact penalty μ_i · dist_{K_i}(·) and solves the penalized problem with COSMO/OSQP-style ADMM. The only algorithmic change from COSMO is that the cone projection becomes the prox of the distance penalty. That prox is evaluated as v − Π_{C_i}(v), where C_i = κ_i B_i* ∩ K_i°, at the cost of a projection.

The paper's main results are:

  • Exactness. The penalty is exact when μ_i exceeds the dual norm of the optimal multiplier block (Theorem 2.3).
  • Bounded duals. Dual iterates stay bounded by μ on every problem (Prop. 2.6b).
  • Convergence. ADMM converges to a KKT point of the penalized problem whether or not the original is feasible.
  • Minimum-violation limit. As the penalties grow, the solution tends to a minimum-violation point (Prop. 2.5).

Because every instance follows the same code path, the solver can be batched on a GPU and unrolled. Following prior work on deep unfolding, the authors learn step-size and warm-start policies with a self-supervised loss on the penalized KKT residuals. Experiments cover six learning benchmarks: closed-loop covariance steering and 3-DoF powered descent; open-loop 6-DoF powered descent SCP; and LP-based robustness certification of ReLU networks.

Critical strengths
  1. A simple, useful idea that fits existing solvers. The modification changes one line of a COSMO-style solver, costs no more than a projection, and turns infeasible subproblems into usable minimum-violation steps. This matters in practice for SCP and MPC.
  2. Clear theory with useful certificates. The block-wise exactness conditions and closed-form proxes for polyhedral, SOC, and PSD cones (Table 1) are clean. Theorem 2.3(b) is a practical a posteriori check: if no block is saturated, the original problem has been solved. Corollary 2.4 links saturated blocks to irreducible infeasible subsystems.
  3. Enables self-supervised unfolding on infeasible instances. Because the multipliers stay bounded, a residual-based loss is well defined on infeasible problems, where diverging COSMO duals give no finite target.
  4. Convincing control results where the comparison is fair. In 6-DoF SCP, FlexCone matches COSMO with virtual controls (20/20 solved). It uses about 5× fewer ADMM iterations and 9× less time, without enlarging the subproblem by 1,400 variables and constraints.
  5. Clear writing and a well-documented experimental protocol in the appendices.
Critical weaknesses
  1. The novelty of the theory is overstated. Exact penalization of convex programs with general (including conic) constraints, with exactness once the penalty exceeds the dual norm of an optimal multiplier, is classical. It goes well beyond the ℓ1/linear case cited (see, e.g., the exact-penalization literature of Bertsekas and of Burke, and elastic-mode SQP). Proposition 2.5 is the standard penalty-path result, and Corollary 2.7 follows from standard ADMM convergence. The genuine contributions are the cone-specific proxes, the in-solver implementation, and the unfolding use case. The text should position Section 2 accordingly and cite this literature. The paper also builds directly on Deep FlexQP (Oshin et al., 2026a) and the conic unfolding framework of Oshin et al. (2026b); the improvements over these, particularly the extension of the relaxation to SOC/PSD blocks, should be stated more precisely.

  2. The penalty μ is calibrated using exact solves, which weakens the "always-feasible, no tuning" message. In every experiment, μ_i is set to 1.5× the largest multiplier norm found by exact interior-point solves on training or calibration problems (Appendices C, D.3, E.1). If μ is too small at deployment, FlexCone silently solves a different problem on feasible instances, trading objective against violation. If μ is too large, the method approaches hard constraints with poorer conditioning. Please add a sensitivity study across a wide range of μ, including the fraction of feasible test subproblems that end up saturated (i.e., not solved exactly), and discuss how μ would be chosen without a reference solver.

  3. Two of the three control baselines are straw men. In covariance steering and 3-DoF powered descent, the baseline is COSMO falling back to the previous plan whenever a subproblem is infeasible or hits the iteration budget. Practitioners would instead use soft constraints or slack variables (virtual controls, as in the 6-DoF experiment), or an interior-point solver with an elastic formulation. In covariance steering, COSMO also runs with hyperparameters tuned for FlexCone, since COSMO's own tuning "only completed at most 1 of 10 episodes" (Appendix D.3). In 3-DoF powered descent, COSMO's fallbacks come "mostly by exhausting its iteration budget", not from infeasibility, so the 19/60 vs 54/60 result partly reflects convergence speed. Please add COSMO with an explicit ℓ1-slack formulation (and ideally Clarabel with slacks) for both closed-loop tasks.

  4. Unexplained behavior on feasible problems. The paper says that on feasible problems, FlexCone "takes the same steps as COSMO" whenever multipliers stay below μ (Section 1, Prop. 2.6c). Yet in Table 2, the unlearned FlexCone needs about 3.5× more median iterations than COSMO on CS Double Integrator (1068 vs 304) and more on Lovász ϑ (156 vs 107). For learned solvers, learned FlexCone has a much worse tail than learned COSMO on CS Unicycle: 90th-percentile iterations 264 vs 47, and time 19.0 s vs 1.91 s. The claim that it "matches or improves on learned COSMO in median iterations on every class" is true but hides this tail regression. Please explain these differences (e.g., transient saturation of blocks) and report tail metrics in the text.

  5. The robustness-certification timing compares unlike hardware and tools. FlexCone solves each fold as one GPU batch, while HiGHS and COSMO.jl solve the problems serially on a CPU. The stated speedups therefore mainly reflect batching and hardware. Fairer comparisons would be a batched GPU LP solver (e.g., cuPDLP) and established GPU verification tools that bound the same LP relaxation (e.g., CROWN-family bound propagation). The interpretability claim (few violated rows identify which relaxations to loosen) is interesting but is not evaluated beyond counts.

  6. Scale and statistics.

    • The learning benchmarks use 100 training and 20 test instances per class.
    • The closed-loop experiments use 20 scenarios × 3 seeds.
    • The learning benchmarks solve one instance at a time on the GPU (Appendix C), and the control experiments run on the CPU with a sparse LDLᵀ factorization (Appendices D.3, E.1). The batching advantage the paper emphasizes is therefore tested only in the certification experiment.

    Results on larger problems, and batched-throughput numbers for the control and benchmark settings, would strengthen the scalability argument.

  7. Minor issues.

    • The title's "always-feasible" is misleading. The solver always returns a point (a KKT point of the penalized problem), but that point is not feasible for an infeasible problem. "Always-solvable" or "infeasibility-robust" would be more accurate.
    • The trust region is enforced with a penalty scaled by 10⁶. Its interaction with conditioning and the PCG solve deserves comment.
Questions for authors
  1. How sensitive are the closed-loop and benchmark results to μ (e.g., 0.1× to 10× the calibrated value)? What fraction of feasible test subproblems end up saturated?
  2. How does COSMO (or Clarabel) with an explicit ℓ1-slack formulation compare on covariance steering and 3-DoF powered descent?
  3. Why does unlearned FlexCone need more iterations than COSMO on CS Double Integrator and Lovász ϑ, given that the steps coincide when no block is saturated? What causes learned FlexCone's tail on CS Unicycle?
  4. How does certification time compare with a batched GPU LP solver, or with bound-propagation verifiers on the same relaxation?
  5. Can μ be adapted online (e.g., increased when Theorem 2.3(b) detects saturation on a problem known to be feasible), and does Corollary 2.7 still apply?
  6. What exactly is new relative to Deep FlexQP beyond the SOC/PSD proxes?
4 comments
AuthorsOpenReview ↗

Response to Reviewer jNTf (Part 1/4)

We thank the reviewer for their constructure review and overall positive assessment of our work. We performed an additional literature review and ran the requested experiments. Some of the results have adjusted our claims, which we discuss below. Overall, we feel that the feedback has led to a substantially improved submission.

W1 / Q6 - Novelty of the theory

We agree that the novelty is overstated. Namely, the dual characterization, saturation, and exactness theorem are special cases of [1], which studies exact penalization of g(x)∈Cg(x) \in C for a general closed convex set CC. Proposition 2.5 is already stated as a classical result and we added the relevant citations [2, 3]. Corollary 2.7 follows from standard ADMM convergence and we cite [4]. We included missing elastic SQP citations [5] and [6]. Our novel contributions are the ones the reviewer lists: the cone-specific proxes at the cost of a projection, the in-solver implementation, and the unfolding use case.

Relative to Deep FlexQP (Oshin et al. 2026a), we make the following contributions:

  • No slack variables. Deep FlexQP relaxes its polyhedral constraints using explicit slack variables, which our formulation avoids. This avoids introducing additional variables and hyperparameters into the algorithm, and our linear system is therefore identical to COSMO's.
  • Extension to SOC and PSD blocks. The relaxed conic constraints cannot be written using a simple soft threshold on scalar slack variables as in Deep FlexQP. The prox instead requires v−ΠC(v)v - \Pi_C(v) with CC the intersection of the dual-norm ball and polar cone.
  • Multiplier bounds for iteration-varying step sizes (Proposition 2.6b). Our dual multiplier bounds hold for every iterate under an iteration-varying step size, not only at the solution as in Deep FlexQP.
  • Self-supervised loss. Deep FlexQP trains exclusively on feasible instances and requires a reference solver. We propose a self-supervised loss based on the penalized optimality conditions that generalizes to infeasible instances and does not require a reference solution.

Relative to Oshin et al. 2026b, they unroll COSMO (with hard constraints) and reject infeasible samples during dataset generation. Our contributions are the modified second ADMM block and the loss, which allows for training and deployment on infeasible instances, along with the novel capability demonstration on closed-loop control and robustness certification tasks. Both of these have now been highlighted in the related work section.

References:

  • [1] Burke, J. V. (1991). An exact penalization viewpoint of constrained optimization. SIAM Journal on Control and Optimization.
  • [2] Friedlander, M. P., & Tseng, P. (2008). Exact regularization of convex programs. SIAM Journal on Optimization.
  • [3] Bertsekas, D. P. (1975). Necessary and sufficient conditions for a penalty method to be exact. Mathematical Programming.
  • [4] Eckstein, J., & Bertsekas, D. P. (1992). On the Douglas—Rachford splitting method and the proximal point algorithm for maximal monotone operators. Mathematical Programming.
  • [5] Brown, G., & Graves, G. (1975). Elastic programming: a new approach to large-scale mixed integer optimization. ORSA/TIMS Conference.
  • [6] Burke, J. V., & Han, S. P. (1989). A robust sequential quadratic programming method. Mathematical Programming.
AuthorsOpenReview ↗

Response to Reviewer jNTf (Part 2/4)

W2 / Q1 / Q5 - Sensitivity to μ\mu

We re-ran both closed-loop tasks with the penalty scaled from 0.1$\times$ to 10$\times$ the calibrated value from the original submission, and classified every subproblem as feasible or infeasible (using Clarabel).

Powered descent:

scale0.1×0.3×1× (paper)3×10×
Successes (out of 60)2258543025
Feasible subproblems saturated23%2.2%0.4%0.15%0%

Covariance steering:

scale0.1×0.3×1× (paper)3×10×
Successes (out of 60)233752529
Feasible subproblems saturated49%50%39%38%32%

The reviewer's concern is largely justified. The tuned penalty sits within a working window of about 0.3-3$\times$ and performance degrades on both sides. We will add this study and further explain the sensitivity to the choice of μ\mu in the updated submission.

Notably, performance on the closed-loop control experiments degrades for large μ\mu, but the cause is not due to poor conditioning. μ\mu only enters the prox threshold and not the linear system, and the iterations on feasible subproblems do not change with μ\mu. For example, on powered descent, the median iterations were 129–132 for μ\mu 0.3×0.3\times to 10×10\times the tuned value. A large μ\mu instead causes longer dual ascent for infeasible subproblems, causing the budget to be reached more often. In these cases, FlexCone approaches COSMO's behaviour, as Proposition 2.6c predicts.

Meanwhile, on the benchmark problems from Table 2, FlexCone and learned FlexCone are insensitive to overestimations of μ\mu. At 10$\times$ and 100$\times$ the submission μ\mu, the iterations and wall-clock time to convergence are within 5% of the 1$\times$ numbers. On the other hand, underestimation means FlexCone solves a relaxed problem since the condition μi>∥yi∗∥∗\mu_i > \lVert y_i^* \rVert_* no longer holds, and the iteration counts and times vary.

Therefore, we recommend setting μi\mu_i to 1.5$\times$ the largest multiplier norm observed on a small set of calibration problems, which is the rule used for every experiment in the submission. For a mixed stream of feasible and infeasible problems, the calibration should use the feasible instances, as that choice balances performance on feasible and infeasible instances. The a posteriori test of Theorem 2.3b then certifies each returned point. We also studied adapting μ\mu online by monitoring the saturation of the dual variable blocks. On max-cut and Lovász ϑ\vartheta, where the optimal multiplier grows with problem size, this rule successfully solves every instance up to 5×5\times the training size, and Corollary 2.7 applies once μ\mu stops changing, as it does for ρ\rho. However, it occasionally hurt performance on the closed-loop tasks, so we do not yet recommend it as the default. We will continue to investigate the adaptive scheme in the closed-loop setting to minimize the cost of determining μ\mu for the practitioner.

W3 / Q2 - Slack baselines

We agree that an elastic baseline is the fairer comparison. We re-ran the closed-loop control experiments using COSMO, Clarabel, and PDHCG (suggested by reviewer z4m6) with an explicit ℓ1\ell_1 slack formulation.

3-DoF powered descent:

MethodSuccesses (out of 60)Median / p90 time per subproblem (s)Median / p90 time to success (s)
FlexCone (re-measured)54 (90%)0.101 / 0.32510.1 / 19.0
COSMO slacks0 (0%)0.155 / 2.68N/A
Clarabel slacks8 (13%)0.020 / 0.0342.9 / 3.0
PDHCG slacks2 (3%)1.14 / 3.4765 / 75

Iterative covariance steering:

MethodSuccesses (out of 60)Median / p90 time per subproblem (s)Median / p90 time to success (s)
FlexCone (re-measured)52 (87%)0.47 / 3.67150 / 223
COSMO slacks58 (97%)2.1 / 40.81420 / 1780
Clarabel slacks60 (100%)10.5 / 12.8921 / 944
PDHCG slacks24 (40%)15.7 / 45.11790 / 2170

On powered descent, while Clarabel is the fastest solver overall, all the slack baselines have limited successes. Meanwhile, on iterative covariance steering, FlexCone achieves an 87% success rate with the fastest subproblem time and time to success amongst the slack arms. COSMO slacks and Clarabel slacks achieve high success rates but suffer from a slow solve time due to the size of the SDP subproblems. These results further support our claim that FlexCone provides a unique capability over existing/standard techniques.

AuthorsOpenReview ↗

Response to Reviewer jNTf (Part 3/4)

W4 / Q3 - Behavior on feasible problems

Unlearned gap. The two unlearned arms of Table 2 unintentionally used different initial ρ\rho values: COSMO used the default 100 for equality constraints and 0.1 otherwise, and FlexCone used values from a small hyperparameter sweep. With the same starting ρ\rho, the two solvers produce bit-identical iterates on all 20 Lovász ϑ\vartheta instances (107 / 119 iterations for both). The behavior differs on the CS double integrator problems, in favor of FlexCone:

MethodIterationsTime (s)
COSMO (submission ρ\rho)304 / 68529.7 / 61.0
FlexCone (submission ρ\rho)1068 / 119917.5 / 19.2
COSMO with FlexCone's ρ\rho4666 / 1000077.5 / 600
FlexCone with COSMO's ρ\rho307 / 39829.1 / 36.8

FlexCone with COSMO's ρ\rho produces the same median iterations but with a better tail. Meanwhile, COSMO with FlexCone's ρ\rho has a much worse performance and results in 8/20 failures. The advantage can be attributed to FlexCone's choice of μ\mu: the calibrated penalty on the equality blocks is small, which caps the dual multipliers of FlexCone during the optimization. Meanwhile, COSMO overshoots their value at the first iteration by 5 to 6 orders of magnitude, then spends most of its iterations driving them back down. Note that less iterations does not imply less wall-clock time due to differing CG steps, as ρ\rho affects the conditioning of the linear system. We added an appendix section with this comparison and explanation.

Learned tail. The slow tail for learned FlexCone is not caused by saturation. No block reaches its penalty on any unicycle instance, and the same policy run with COSMO's projection reproduces the iteration counts instance by instance. The slow tail is caused by a few outlier subproblems generated from the initial linearizations of two of the held-out trajectories. On these instances, the learned policy drives ρ\rho and α\alpha to their bounds and the residual then decays slowly. This is a limitation of the trained policy rather than of the prox, and this has been reported in the updated submission.

W5 / Q4 - Certification

We agree and ran the fairer comparison against CROWN. CROWN failed 8 of the MNIST instances but otherwise produced verifications at sub-millisecond times.

Seconds per input (mean over three folds):

MethodMNIST 0.05MNIST 0.1CIFAR-10 1/255CIFAR-10 2/255
COSMO.jl0.521.0039.648.3
FlexCone0.00380.00531.371.52
HiGHS0.310.365.306.21
CROWN0.0000180.0000180.000270.00028

We no longer present certification as a speed result and have revised the text accordingly. Our contribution is the capability demonstration and the returned point: FlexCone’s final iterate is within 0.04% of the minimum possible weighted violation (median ratio 1.0002–1.0004; 99% of problems within 1%) with 99% of that violation localized to 3 constraints, whereas COSMO stalls at ratios of 2.6× (MNIST) and 7.2× (CIFAR-10) the minimum, spread over about 1,000 of 2,000 and 10,900 of 19,000 constraints respectively. Loosening the identified rows repairs the system at minimum cost on 100% of systems, which is a capability not provided by CROWN. We also tried a learned policy trained on mixed feasible and infeasible instances, which reduced iteration counts by 1.2$\times$ but did not improve the end-to-end wall-clock speed, which we report as a mixed result.

AuthorsOpenReview ↗

Response to Reviewer jNTf (Part 4/4)

W6 - Scale and batching

Batched results. Batching helps significantly on the SDPs. With a batch size of 64, learned FlexCone is 25-31$\times$ cheaper per instance than sequential Clarabel on max-cut and Lovász ϑ\vartheta. However, on the SOCPs (robust MPC and robust KF), learned FlexCone is 30$\times$ slower than Clarabel, which is expected because the interior-point method excels at these small SOCPs. For the control problems, batching 8-64 instances together produces a modest speedup of 1.2-1.7$\times$. The major limiting factor is that the batch is limited by its slowest instance, which we found often requires 9-10$\times$ the mean instances's iterations.

Larger problems. Using the trained models from Table 2, learned FlexCone keeps its iteration count flat on SOCP instances up to 10×10\times larger than those seen in training (17 iterations at horizon 500 for robust MPC, 40 at horizon 1000 for the robust Kalman filter). In contrast, the learned policies do not generalize to max-cut and Lovász ϑ\vartheta instances that are 22–10×10\times larger. We hypothesize that the difference comes from how each problem class scales. Lengthening the horizon of an SOCP adds more second-order cones with the same dimension and the same coupling pattern. The larger problem is therefore built from local structure the policy has already seen. Growing an SDP instead enlarges the semidefinite cone itself, and both the constraint matrix and the cone dimension change. These larger instances fall outside the training distribution.

W7 - Minor issues

Title. We respectfully prefer to keep "always-feasible". It describes the solver, whose problem always has a solution, not the returned point. This follows from the usage of the term in Deep FlexQP and other related work, such as [7].

Trust region. The 10610^6 scaling multiplies the prox threshold μi/ρ\mu_i / \rho of the trust-region rows only. It does not enter the matrix P+σI+ρA⊤AP + \sigma I + \rho A^\top A, so the conditioning and the PCG solve are unchanged. By Proposition 2.6c, the prox on those rows is the projection, so the trust region is handled exactly as in COSMO. We have clarified this in the text.

References:

  • [7] Morton, D., Arrizabalaga, J., Manchester, Z., & Pavone, M. (2026). ElastiQP: An always-feasible QP solver for constrained robot control. arXiv preprint arXiv:2609.19080.
Reviewer_KxbdOpenReview ↗
Rating
2
Confidence
1
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes FlexCone, an always-feasible first-order solver for conic optimization that applies ADMM to an exact distance-penalty relaxation. The method recovers the original solution on feasible problems and returns a minimum-violation point on infeasible ones. The paper establishes exactness and convergence results, develops closed-form proximal operators for several cone types, and demonstrates the method on optimization, control, trajectory optimization, and neural-network robustness certification tasks.

Critical strengths

FlexCone addresses a meaningful practical problem by returning a bounded minimum-violation point even when a conic subproblem is infeasible. This gives the outer optimization or control procedure an actionable point instead of only an infeasibility certificate or a fallback to a stale solution.

Critical weaknesses

The treatment of infeasible solutions and the associated termination criterion is not fully clear. In particular, it is difficult to tell how the proposed residual distinguishes convergence to a penalized infeasible point from satisfaction of the original cone constraints.

Questions for authors
  1. Could you clarify how the residual and termination criterion should be interpreted when the penalized solution remains infeasible?
  2. How are the penalty values selected for new infeasible instances, and how sensitive is FlexCone to a mismatch between the calibration and test multiplier scales?
  3. In the robustness certification experiments, how much of the reported speedup comes from FlexCone itself versus GPU batching and the comparison with serial CPU baselines?
1 comment
AuthorsOpenReview ↗

Response to Reviewer Kxbd

We thank the reviewer for the helpful feedback and have revised the text as detailed below. We hope that this addresses your concerns with our submission.

Q1 - Interpreting the residual and termination test on infeasible problems

The termination test measures convergence to a solution of the penalized problem (Proposition 2.2). Whether the original cone constraints hold is decided by two quantities the solver returns with the solution:

  • the cone violation distKi(bi−Aix^)\mathrm{dist}_{K_i}(b_i - A_i \hat{x}) of each block, zero iff the block is satisfied, and
  • the saturation check of Theorem 2.3b: if no multiplier block reaches its penalty μi\mu_i, the returned point solves the original problem.

A violated block is always saturated (Proposition 2.2), and an infeasible problem always has a saturated block (Corollary 2.4). The solver thus reports either "converged, no block saturated" (a solution of the original problem) or "converged, with these blocks saturated and violated by these amounts" (a minimum-violation step). The submission stated this in one sentence after Corollary 2.7. We now explain the termination check more clearly and corrected the sentence in Section 2.4 that suggested the residual includes the original cone violation on infeasible problems.

Q2 - Selecting the penalty and sensitivity to a mismatch

μ\mu should be chosen roughly proportional to the constraint scales, based on the following evidence.

On the Table 2 benchmarks, FlexCone and learned FlexCone are insensitive to overestimating μ\mu: at 10$\times$ and 100$\times$ the submission μ\mu, iterations and wall-clock time are within 5% of the 1$\times$ numbers. Underestimation means FlexCone solves a relaxed problem, since μi>∥yi∗∥∗\mu_i > \lVert y_i^* \rVert_* no longer holds, and iterations and times vary. For a new family of feasible instances, we thus recommend setting μi\mu_i to 1.5$\times$ the largest multiplier norm observed on a small calibration set.

On the closed-loop tasks, we scaled the penalty from 0.1$\times$ to 10$\times$:

Powered descent:

scale0.1×0.3×1× (paper)3×10×
Successes (out of 60)2258543025
Feasible subproblems saturated23%2.2%0.4%0.15%0%

Covariance steering:

scale0.1×0.3×1× (paper)3×10×
Successes (out of 60)233752529
Feasible subproblems saturated49%50%39%38%32%

The tuned penalty sits within a working window of about 0.3-3$\times$, and performance degrades on both sides. The degradation at large μ\mu is not due to poor conditioning: a large μ\mu lengthens dual ascent on infeasible subproblems, so the iteration budget is reached more often. FlexCone then approaches COSMO's behaviour, as Proposition 2.6c predicts.

The choice of μ\mu is therefore a tradeoff set by the deployment regime. Feasible problems only need μi>∥yi∗∥∗\mu_i > \lVert y_i^* \rVert_*, beyond which convergence is unchanged; infeasible problems favor a small μ\mu to shorten dual ascent. For a mixed stream, we recommend the 1.5$\times$ rule calibrated on feasible instances, which balances both. This rule was used for every experiment in the submission, and the a posteriori test of Theorem 2.3b certifies each returned point. We also studied adapting μ\mu online by monitoring dual block saturation. On max-cut and Lovász ϑ\vartheta, where the optimal multiplier grows with problem size, this solves every instance up to 5×5\times the training size, but it occasionally hurt the closed-loop control tasks, so we do not yet recommend it as the default. We will continue investigating it to reduce the cost of choosing μ\mu for practitioners.

Q3 - Source of the certification speedup

The speedup over the serial CPU baselines is primarily due to batching. Replacing the prox with the projection gives similar solve times, but FlexCone attains the exact minimum violation (ratio 1.00) while the projection gives 2.6–7.3$\times$ more violated rows. Following Reviewer jNTf, we also compared with a stronger baseline, CROWN, which failed 8 MNIST instances but otherwise verified at sub-millisecond times.

Seconds per input (mean over three folds):

MethodMNIST 0.05MNIST 0.1CIFAR-10 1/255CIFAR-10 2/255
COSMO.jl0.521.0039.648.3
FlexCone0.00380.00531.371.52
HiGHS0.310.365.306.21
CROWN0.0000180.0000180.000270.00028

We no longer present certification as a speed result and have revised the text accordingly. Our contribution is the capability demonstration and the returned point: loosening the rows identified by FlexCone repairs 100% of systems at minimum cost, a capability CROWN does not provide. A learned policy trained on mixed feasible and infeasible instances reduced iterations by 1.2$\times$ but did not improve end-to-end wall-clock time, which we report as a mixed result.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.