Sequential Conic Optimization

• Sequential Conic Optimization is a framework that iteratively refines conic subproblems to handle nonconvex and complex optimal control challenges.
• It encompasses distinct methods including SCP-based, SQP-based, and augmented Lagrangian techniques, each leveraging projection-friendly and matrix-free solvers.
• Practical applications in rocket guidance, robotics, and large-scale SDPs show substantial speedups via warm starts and tailored first-order iterations.

Sequential Conic Optimization (SeCO) denotes a family of sequential methods in which a nonlinear, nonconvex, or otherwise difficult problem is attacked through a succession of conic subproblems whose models, approximations, or solver states are updated across iterations. In the recent literature, the term is used in at least three technically distinct senses: as a matrix-factorization-free sequential convex programming framework for real-time optimal control; as a sequential quadratic programming method for linear second-order cone programs that solves only QP subproblems; and as an augmented Lagrangian scheme for nonlinear conic programming with progressively refined cone approximations. A 2026 line of work further studies how deep-unfolded conic solvers can enable and accelerate SeCO when the inner subproblems are large-scale SDPs or SOCPs arising in robotics (Kamath et al., 2022, Luo et al., 2022, Fukuda et al., 2024, Kamath et al., 14 Aug 2025, Oshin et al., 11 Jun 2026).

1. Terminological scope and principal formulations

In the rocket-guidance and robotics literature, SeCO is introduced as a framework that combines sequential convex programming (SCP) with first-order conic optimization. The 2022 multi-phase rocket landing paper describes SeCO as a “matrix-factorization-free and inversion-free framework for solving nonconvex optimal control problems in real time,” combining SCP with the proportional–integral projected gradient method (PIPG) so that each convexified subproblem is solved by matrix–vector operations and projections onto simple convex sets. The 2025 onboard dual quaternion guidance work retains this interpretation, emphasizing first-order primal-dual conic optimization, warm-starting, extrapolation, and embedded implementation on flight hardware (Kamath et al., 2022, Kamath et al., 14 Aug 2025).

A different use of the term appears in work on linear SOCPs, where SeCO is a Sequential Quadratic Programming method tailored to second-order cone constraints. In that formulation, cone non-differentiability is handled by polyhedral outer approximations, the subproblems are QPs solved by an active-set method, and the final local regime becomes identical to smooth SQP on an equivalent differentiable problem under nondegeneracy. Warm-start capability is central because all subproblems are QPs and can inherit active sets and factorizations (Luo et al., 2022).

A third formulation uses SeCO to mean a sequential cone-approximation strategy inside an augmented Lagrangian method for nonlinear conic programming. There, the original cone $K$ is replaced by a sequence of simpler cones $K^k$, the augmented Lagrangian uses projections onto the polar of $K^k$, and the cone approximation is refined during the outer iteration. The theoretical emphasis is not real-time control but strong sequential optimality and KKT convergence under Robinson’s condition (Fukuda et al., 2024).

This multiplicity of definitions is important. In the surveyed literature, SeCO does not designate a single canonical algorithm; it designates a sequential conic methodology whose concrete instantiation depends on whether the governing outer iteration is SCP, SQP-with-cuts, or augmented Lagrangian refinement.

2. SCP-based SeCO for nonconvex optimal control

In the SCP-based line, SeCO addresses nonconvex optimal control problems by repeatedly linearizing or convexifying around a reference trajectory and solving the resulting conic subproblem. The 2022 rocket-landing formulation starts from continuous-time dynamics

$\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$

with free phase-transition times, convex state and control constraints, and single-crossing compound state-triggered constraints (STCs). A key device is time-interval dilation: on each interval $[t_k,t_{k+1})$,

$$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$

so that the dilated dynamics become

$\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$

This converts the free-transition-time problem into an equivalent fixed-horizon formulation while allowing per-phase durations to remain decision variables. The method uses FOH for smooth phases and ZOH around switching events, and computes exact discrete linearized dynamics by integrating IVPs for the state-transition and input/dilation maps rather than using matrix exponentials or inversions (Kamath et al., 2022).

The convex subproblem is then assembled in conic form with exact discrete dynamics, control and state constraints, and two regularizing mechanisms: a penalized trust region (PTR) and a virtual state. The virtual state $\xi$ duplicates the state dimension, carries the state constraints, and is penalized against the dynamics state $x$ through

$J_{\mathrm{vse}} = \sum_{k=1}^N \|x_k-\xi_k\|_2^2.$

This decoupling is used to eliminate artificial infeasibility while preserving the dynamics manifold and the geometry of the original state-constraint sets. The overall merit function combines objective, trust-region penalty, and virtual-state penalty, and SCP accept/reject decisions are made through sufficient reduction in that merit function (Kamath et al., 2022).

The 2025 dual-quaternion guidance formulation applies the same architecture to a 6-DoF powered-descent problem with a 15-dimensional state including mass, an 8-dimensional unit dual quaternion, and a reduced-order 6-dimensional dual velocity. Time-dilation converts free-final-time dynamics to a fixed interval $K^k$0, FOH is used for controls, dynamics are linearized to obtain $K^k$1, and the resulting subproblem is written in the strongly convex conic form

$K^k$2

Here $K^k$3 encodes dynamics as zero-cone equalities, while $K^k$4 encodes boxes, balls, halfspaces, and subspaces so that path constraints admit closed-form projections (Kamath et al., 14 Aug 2025).

Within this line of work, STCs are not treated as generic logic constraints. The 2022 paper introduces single-crossing compound STCs, which remain convex when both the trigger and constraint conditions are convex and the trigger is single crossing. The 2025 paper instead combines global and STC bounds through a trigger function $K^k$5 and linearizes tilt and line-of-sight constraints into halfspaces, again to preserve projection-friendly structure (Kamath et al., 2022, Kamath et al., 14 Aug 2025).

3. Inner conic solvers: matrix–vector iterations, projections, and warm starts

The first-order solver at the core of SCP-based SeCO is PIPG or its extrapolated/customized variants. For the graph-form conic problem

$K^k$6

the extrapolated PIPG iteration used in the 2022 formulation is

$K^k$7

$K^k$8

$K^k$9

The defining computational property is that the method is matrix-factorization-free and inversion-free: each iteration uses matrix–vector multiplies with $K^k$0 and $K^k$1, together with projections onto cones and boxes, rather than KKT factorizations or linear solves (Kamath et al., 2022).

The 2025 DQG work uses a customized first-order primal-dual conic solver based on PIPG together with hypersphere preconditioning. In the preconditioned variables, the objective Hessian becomes $K^k$2, giving condition number $K^k$3, and the primal step size is

$K^k$4

The projected-gradient and dual PI-feedback steps are then

$K^k$5

$K^k$6

followed by extrapolation. Because the relevant sets are boxes, balls, halfspaces, subspaces, and zero cones, all projections remain closed form (Kamath et al., 14 Aug 2025).

Warm starts are a structural feature of these SeCO variants. In the 2022 rocket-landing setting, the previous SCP iterate is used to initialize xPIPG. In the 2025 DQG setting, the warm start may come either from the previous SeCO iteration or from the previous guidance cycle. This is paired with extrapolation and sparsity-aware devectorization, so that large sparse operations are replaced by small dense operations over temporal slices. The motivation is deterministic embedded performance, small code footprint, and suitability for real-time update rates on resource-constrained hardware (Kamath et al., 2022, Kamath et al., 14 Aug 2025).

A common misconception is that first-order SeCO solves only loosely constrained problems. In the cited SCP-based formulations, the point is the opposite: conic reformulation is used precisely because the relevant convex sets admit exact projections, so path constraints can be enforced through projection operations at each inner iteration rather than relaxed into generic penalties.

4. Large-scale SDPs, deep unfolding, and learned SeCO acceleration

A later development studies SeCO when the inner SCP subproblems are not only SOCPs but also large-scale SDPs, as in covariance steering and related robotics problems. The conic subproblem is written in the standard form

$K^k$7

and a full-update ADMM conic solver in the COSMO style is unrolled for a fixed number of iterations. In this setting, SeCO is the repeated solution of conic subproblems generated by sequential convex programming, while the contribution is to make the backward pass through the solver scalable and numerically stable enough to train learned hyperparameter policies and warm starts (Oshin et al., 11 Jun 2026).

Two obstacles are identified. First, backpropagating through the per-iteration linear-system solve becomes prohibitively memory-intensive if dense normal equations are formed explicitly. This is addressed by a matrix-free implicit differentiation rule based on the reduced system

$K^k$8

together with the adjoint equation

$K^k$9

which yields, in the matrix-only term,

$\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$0

All required quantities are obtained through matvecs $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$1, $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$2, $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$3, and CG solves with $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$4. The coefficient matrix is never formed. The paper reports that memory drops from $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$5 to $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$6; dense baselines exhaust 24 GB around $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$7 variables, while the matrix-free rule stays under 300 MB at $\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$8 (Oshin et al., 11 Jun 2026).

Second, backpropagating through the PSD cone projection becomes unstable when eigenvalues coincide. The forward projection is

$\dot{x}(t) = f\!\bigl(t,x(t),u(t)\bigr),$9

and the stable backward rule uses the Dalečkii–Krein Fréchet derivative

$[t_k,t_{k+1})$0

where the Löwner matrix $[t_k,t_{k+1})$1 is formed from divided differences of $[t_k,t_{k+1})$2. This removes the $[t_k,t_{k+1})$3 blow-up present in naive eigendecomposition gradients and remains well-defined under repeated eigenvalues, including isotropic covariance constraints (Oshin et al., 11 Jun 2026).

With these two components in place, the paper learns per-iteration penalties $[t_k,t_{k+1})$4, relaxations $[t_k,t_{k+1})$5, and warm starts for $[t_k,t_{k+1})$6 using small ReLU MLPs under a fixed unroll length of 50–100 ADMM iterations. Reported performance includes up to $[t_k,t_{k+1})$7 speedup on standalone conic problems, including a $[t_k,t_{k+1})$8 time speedup and $[t_k,t_{k+1})$9 fewer iterations on a Lovász $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$0 SDP, and over $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$1 end-to-end speedup when the learned solver is embedded inside SCP for nonlinear covariance steering (Oshin et al., 11 Jun 2026).

5. SeCO beyond SCP: SQP with cuts and augmented Lagrangian refinement

In the SQP-based interpretation, SeCO is specialized to linear SOCPs and treats the cone constraints from a nonlinear-programming perspective. Each second-order cone block $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$2 can be written through

$$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$3

but $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$4 is non-differentiable at $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$5. The method therefore replaces each cone by a polyhedral outer approximation built from supporting hyperplanes, solves a QP subproblem, and refines the approximation by primal and dual cut generation. The outer-approximation QP uses a Hessian model

$$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$6

linearized differentiable cone constraints, and polyhedral approximations $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$7. Globalization is performed with the exact penalty merit function

$$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$8

Under boundedness of $$\tau_k(t) = \frac{t - t_k}{t_{k+1}^- - t_k}, \qquad s_k := t_{k+1}^- - t_k \in \mathbb{R}_+,$$9 and Slater’s condition, limit points are SOCP primal-dual solutions; under nondegeneracy and strict complementarity, the algorithm finitely identifies extremal-active cones and then reduces to smooth SQP with second-order correction, yielding local quadratic convergence. Because all subproblems are QPs, active-set warm starts are intrinsic to the method (Luo et al., 2022).

In the augmented-Lagrangian interpretation, SeCO addresses general nonlinear conic programs

$\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$0

without requiring direct access to the full cone $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$1. Instead, it uses a continuous approximation $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$2 of $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$3 and the safeguarded augmented Lagrangian

$\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$4

Each outer iteration computes an approximate stationary point of this AL subproblem, updates the multiplier by projection onto the polar of $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$5, computes the feasibility-complementarity measure

$\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$6

and either keeps or increases the penalty parameter depending on whether $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$7 contracts sufficiently. The main theoretical statement is that feasible limit points satisfy the relaxed cone approximate gradient projection (R-AGP) condition, and KKT convergence follows under Robinson’s condition (Fukuda et al., 2024).

The paper illustrates this SeCO variant on nonlinear copositive programming using Yıldırım’s polyhedral outer approximations of the copositive cone. Projection onto the polar of the approximate cone is reduced to a convex nonnegative QP with psd Gram matrix, and the approximation is refined sequentially by adding new grid vectors. The reported conclusion is that refining the cone approximation after each AL iteration is generally faster than fixing the closest polyhedral approximation from the start, particularly because early projection QPs are smaller (Fukuda et al., 2024).

6. Applications, empirical performance, and limiting assumptions

The application domain most consistently associated with SeCO is real-time guidance and control. In the 2022 multi-phase rocket-landing study, SeCO solves a unified trajectory optimization problem with ignition, engine downselection, and terminal-descent triggering handled without mixed-integer variables. With $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$8 nodes and averaging over 100 full solves, the reported mean runtime is $\accentset{\circ}{x}(\tau_k) = s_k \, f\!\bigl(t,x(t),u(t)\bigr).$9 ms for PIPG versus $\xi$0 ms for ECOS, corresponding to approximately $\xi$1 speedup; the SCP loop converges in $\xi$2 iterations, and the propellant-consumption difference versus ECOS is $\xi$3 (Kamath et al., 2022).

The 2025 onboard DQG implementation pushes the same general architecture to flight-like hardware. On the NASA SPLICE Descent and Landing Computer, the proposed SeCO+PIPG with $\xi$4 achieves an average solve time of $\xi$5 seconds over 5 SeCO iterations per run across 100 divert sites, meeting the SPLICE requirement of $\xi$6 s and the goal of $\xi$7 s. The paper states that this is roughly $\xi$8 faster than the older SCP+BSOCP implementation on the same platform for comparable mission complexity (Kamath et al., 14 Aug 2025).

In robotics and learned optimization, the 2026 work reports over $\xi$9 speedup end-to-end versus COSMO when the learned solver is embedded inside SCP for nonlinear covariance steering, and a range of standalone improvements at tolerance $x$0, including $x$1 on Lovász $x$2, $x$3 on covariance steering SDP for a double integrator, and about $x$4 on robust SOCPs. In the SQP-SOCP line, cold starts typically require $x$5 iterations, while good warm starts often reduce convergence to about one iteration; on CBLIB benchmarks, warm starts reduce iteration counts by $x$6 and the method solves $x$7 of instances reliably. In the augmented-Lagrangian cone-refinement line, the central numerical observation is lower wall-clock time and lower time per iteration than a standard fixed-approximation AL scheme because the early projection QPs are cheaper (Oshin et al., 11 Jun 2026, Luo et al., 2022, Fukuda et al., 2024).

The limiting assumptions are formulation-dependent. SCP-based SeCO assumes convex or convexifiable constraints, and the 2022 state-triggered-constraint construction requires single crossing for convex compound STCs. PTR and virtual-state penalties are used to manage linearization error and artificial infeasibility, but poor initial references can still demand more outer iterations. The deep-unfolded SDP/SOCP variant is tuned for moderate tolerances near $x$8, still requires $x$9 eigendecompositions for PSD blocks, and does not demonstrate cross-family generalization beyond the training regime. The SQP-SOCP variant requires boundedness, Slater’s condition, and nondegeneracy for its strongest guarantees, while the AL cone-refinement variant requires Robinson’s condition for R-AGP to imply KKT (Kamath et al., 2022, Oshin et al., 11 Jun 2026, Luo et al., 2022, Fukuda et al., 2024).

Taken together, these works show that SeCO is best understood as a sequential conic strategy rather than a single algorithmic template. Its recurring structure is an outer process that updates a model, cone approximation, or reference point, and an inner conic solve that exploits either projection-friendly first-order iterations, warm-started QP subproblems, or refined approximate-cone projections. This suggests that the unifying idea of SeCO is not one solver architecture, but the systematic use of conic subproblems as the computational backbone of sequential optimization.