WorksEngineering
socx: GPU-Accelerated Chance-Constrained Stochastic Optimal Control using JAX
Abstract
In this article, we present socx, a GPU-accelerated solver for lifted convex reformulations of linear stochastic optimal control under chance constraints, implemented in JAX. We demonstrate that by exploiting the sparse and independent structure of the problem, distributed optimization can reduce it to simpler problems: independent linear-quadratic tracking (LQT) problems and Euclidean projections onto sets. These simpler problems can be solved in parallel and then coupled using the constraints. To validate our solver, we run it on a hover-linearized 3D quadrotor and show a speed-up of up to over MOSEK and up to over SCS. socx also solves horizons up to , whereas MOSEK runs out of memory at . We present ablations to isolate the key components that enable the speed-up.
Introduction
Motion planning is a fundamental problem in robotics, as it requires finding an optimal path from the initial to the final state that minimizes length or control effort, is feasible, and avoids obstacles [1]. Autonomous systems such as unmanned aerial vehicles and spacecrafts, face uncertainties, e.g., wrench perturbations, estimation noise, during tasks like safe exploration [2, 3]. Therefore, rather than a single path, the problem becomes one of finding a distribution over paths such that the probability of failure is bounded [4, 5].
Stochastic motion planning is an example of stochastic optimal control, and covariance steering solves such problems by designing feedback to control the state distribution, specifically the mean and covariance, from an initial to a final distribution in a finite time horizon. Covariance steering has many applications in robotics and aerospace. However, to the best of the authors’ knowledge, analytically optimal results are only known for unconstrained cases [6]. For the constrained cases, numerical optimization methods exist that use feedback parameterization, yielding a nonconvex optimization problem with variables. Computationally efficient formulations approximate the constraints, thereby shrinking the feasible set and yielding suboptimal solutions [7, 8]. Recent developments in lifted representations yield problems that can exactly represent linear chance [9] and terminal covariance constraints, with convex approximations for quadratic chance constraints [10], but are computationally prohibitive as the number of variables grows as .
Parallelization introduces a new dimension to algorithm design, enabling new problems to be solved in real time. Batching refers to solving multiple instances of the same problem [11, 12, 13]; it increases the number of solves in a given time, but it neither speeds up a single solve nor directly enables solving longer horizons. In contrast, temporal parallelization speeds up a single solve by representing the backward Riccati recursion and the forward rollout as associative scans, reducing their span from to [14], an approach used in GPU-accelerated iterative linear-quadratic regulator (iLQR) for legged robots [15].
The alternating direction method of multipliers (ADMM) is a distributed optimization algorithm that has become the backbone of several GPU-based convex solvers, but they are generic and do not exploit the full optimal control structure. Being relatively immature, they support fewer constraint types. For example, cuOSQP handles only quadratic programs [22], and cuClarabel restricts the dimension of semidefinite blocks [19]. The splitting conic solver (SCS) with GPU linear solver (cuDSS in backend) supports both second-order cone constraints and semidefinite constraints, but solves the generic Karush-Kuhn-Tucker (KKT) system and does not parallelize independent constraint projections [20].
ADMM has also been specialized for control under uncertainty on GPUs, for robust nonlinear model predictive control [17] and robust trajectory optimization [18]. As robust approaches assume bounded disturbances and account for worst-case uncertainty, they lead to overconservatism and infeasibility when the uncertainty is unbounded [23]. This literature gap is further explained in Table I.
Table I. Comparison with related work. CS: covariance steering. Problem class: Gaussian noise (Gau.), exact linear chance constraints (CC), covariance LMI (LMI), convex (Cvx). Solver structure: exploits OCP structure (OCP), time-parallel span (log ), parallel within one problem (Par.), batches across problems (Bat.), GPU. ✓: yes, ◐: partial or only some works in the group, ×: no, −: not applicable.
Addressing these limitations, we present socx: GPU-accelerated chance-constrained stochastic optimal control using JAX. Our solver exploits the sparse and independent structure of the problem to reduce it to simpler problems: independent linear-quadratic tracking (LQT) problems and Euclidean projections onto sets. These simpler problems can be solved in parallel and then coupled using the constraints. accelerated algorithm implemented in JAX [24] that solves chance-constrained stochastic optimal control by exploiting the lifted convex formulation’s structure and achieves minimal conservatism [10]. The key contributions are: (i) a variable split that breaks the problem into independent LQT problems and closed-form parallel projection operations, (ii) an operator split of linear-quadratic tracking (LQT), P-RIC and P-LQT that enables sharing gains across stochastic channels, uses associative scans for efficient parallelization and is 2.5–4.0× faster per iteration than a sequential LQT, 2.2–7.5× faster than a condensed KKT (Table IV), (iii) a small projection operation for the terminal linear matrix inequality (LMI) constraint via an Gram eigendecomposition instead of an SVD of the factor or a PSD projection of size , which is 22–216× faster per call than the Schur-complement PSD projection, and (iv) validation on 3D linearized quadrotor dynamics demonstrating speed-ups of 7–98× over MOSEK at (–240), 47–2224× faster than SCS+cuDSS. socx solves long-horizon up to , whereas MOSEK runs out of memory at and SCS+cuDSS times out at .
We first review the background on the lifted convex formulation of stochastic optimal control in § 2 and formulate parallel operators in Sec. III. Then, socx is presented in Sec. IV, with simulations and ablations in § 5 followed by the conclusion.
Notation: Boldface letters denote random variables (e.g., , , , ). () is the cone of positive definite (semidefinite) matrices, is the identity, and for . , , and denote the trace, expectation, and variance. is a Gaussian with mean and covariance , and and are the CDFs of the standard Gaussian and the chi-squared distribution with degrees of freedom.
Background: Stochastic Control
We consider the discrete-time stochastic linear time-varying system
where , , and over a horizon .
Assumption 1. The initial state and process noises are mutually independent Gaussian random variables, and . The control is causal and affine in ; this policy class is denoted .
Linear chance constraints on the state and control are
with , , , and . We additionally consider the terminal quadratic chance constraint
and the terminal covariance bound
where and .
The finite-horizon stochastic optimal control problem is
Problem 1 (Linear Stochastic Optimal Control).
subject to (1), (2), (3), and (4) for all . Here , , is the terminal target, and are waypoint targets for .
Lifted Representation
Under Assumption 1, the state and control remain jointly Gaussian. Introduce the independent Gaussian basis
where . Then with , and
with , , , and . Thus
with analogous expressions for .
The lifted dynamics are [10 Lemma 2]
with and .
For Gaussian variables, the linear chance constraints admit the exact second-order cone representation
where and .
The terminal covariance bound is equivalent to
The quadratic chance constraint admits the conservative LMI approximation
or the trace approximation
Their relative conservatism is discussed in [10].
Convex Reformulation
Substituting the lifted representation gives the deterministic convex problem
Problem 2 (Lifted Convex Reformulation).
Theorem 1 (Exact Convex Reformulation). [10 Theorem 1] Under Assumption 1, Problem 2, restricted to (9), (10), and (11), is an exact deterministic convex reformulation of Problem 1: the two problems have equivalent costs and feasible affine policies.
Proposition 1 (Conservative Approximation of QCCs). [10 Proposition 1] Both (12) and (13) are sufficient approximations of (3); neither uniformly dominates the other.
Background: Parallel Primitives
In this section, we review parallel primitives that are packaged as an operator, P-LQT, for solving the Linear-Quadratic Tracking (LQT) problem using an associative-scan that evaluates in span that is invoked for mean and stochastic channels in Section IV.
Parallel Associative Scan
The associative property states that the grouping of operations does not matter, i.e., for an operator , holds. Defining associative operations allows to compute from in span as opposed to a sequential recursion in span [25].
To compute the rollouts of a dynamical system with specified feedback matrices, the following recursion is defined: , called an affine recurrence. This can be expressed as an associative operator, with the -th element being , and the operation being
For prediction horizon , this enables the computation of rollouts in span, instead of . The price is paid because it requires additional operations and memory to store the intermediate matrix [14, 15].
The Parallel LQT Operator
A finite-horizon LQT problem is defined as
with , , , , , being the horizon, start step, state, control input, and transition matrices. And , denote the quadratic costs for state and control with linear terms . Therefore, a problem is fully specified by quadratic and linear parameters ,
here, the subscript denotes the set of matrices with the index varying from to . The optimal law can be represented as an affine-feedback law, . Demonstrated in [14], can be computed from in using an parallel associative scan. We will summarize only the properties and steps that we will use later.
We denote the value function at time step , the minimum cost of starting at state at time , as
Firstly, can be obtained from using associative scan [15] and then the feedback matrix, can be constructed using the relation:
We package this as an operator, P-RIC, which has span, work and memory,
Additionally, following Bellman optimality, depend only on , so an instance that starts at can use the same solve.
Using the feedback matrix, the linear term of the value function, , can be computed using as the recursion
which is an affine recurrence relation in , with . This can be obtained in as defined in Section III-A. The feedforward input can be computed as
Now, as the control input is and the optimal states can be defined using the affine recurrence relation, as the initial state is given:
Combining the two affine recurrences (21) and (23), we package it as an operator:
For fixed , the map given by (21), (22), (23) is linear in . If it is invoked times, in parallel, with shared then it has span, work and memory.
Method
In this section, we present socx by describing (i) the structure of Problem 2; (ii) ADMM with the variable split; (iii) the -update using P-RIC/P-LQT operations; and (iv) the -update as closed-form projections for second-order cone and covariance constraint, as summarized in Figure 1. The resulting solver, socx, does not require Jacobians, KKT matrices, or dense constraint operators.

Figure 1. Steps of ADMM (28) in socx. In one iteration, the -update solves mean and stochastic columns’ LQT problems in parallel, followed by the -update, which projects every chance-constraint cone and the terminal covariance ball in parallel.
Structure of the Lifted Problem
The number of variables in Problem 2 grows as because of the new elements in the stochastic basis. However, the problem is highly structured.
Shared dynamics. Let and denote the columns of and . The following equations govern the stochastic columns , obtained from (9b):
The initial conditions are defined as:
with . Similarly, the mean dynamics are independent of stochastic columns (9a).
Cost separation. In the lifted cost function (14a), the stochastic columns appear through the same matrices, and , and there are no coupling terms across columns.
and likewise for and . The mean variables aren’t coupled with the stochastic columns in the lifted cost function.
Coupling constraints. Second-order cone constraints couple the mean and stochastic channels (14c). The quadratic and the linear matrix inequality constraint couples the stochastic columns (14d).
Dynamics and cost are separable and coupled only through the constraints; therefore, this motivates an optimization algorithm that allows solving subproblems and pooling using the constraints. This structure is what ADMM is designed to exploit when an appropriate variable split is used.
ADMM & Variable Splitting
We review ADMM, a popular algorithm for distributed convex optimization, and then define a variable split. ADMM is well-suited to large-scale problems and combines decomposability with superior convergence properties [26]. It solves problems of the form
by formulating the augmented Lagrangian
and iterating over the update steps
with .
Introducing the scaled dual variable and completing the squares, the last two terms of the augmented Lagrangian, for the case , become
This squared penalty term turns the -update into an LQT (16).
Variable splitting. Collect the primal variables as
For each cone constraint, we introduce a split variable whose size matches the cone. Let correspond to the state and control cone constraint, defined as
Additionally, depending on the terminal constraint, either (11) or (12), the constraint takes the form , with or respectively.
Remark 1. The discussion is limited to the linear matrix inequality as the trace relaxation (13) appears as a quadratic constraint that can be expressed as second-order cone constraint.
Hence, the corresponding split variable is defined as . Collecting the split variables, , an affine operator can be defined as .
Splitting methods handle a convex constraint set by moving it out of the smooth objective and into the indicator function
which is convex and closed whenever is. Hence, resulting in the following ADMM split of Problem 2:
where for the second-order cone constraints and for the terminal covariance constraint. Under this split, the -update becomes independent LQT solves and the -update becomes closed-form set projections as described in the next subsections.
Convergence monitoring. The primal () and dual residuals () are defined as
With an initialization of and , socx monitors the following two conditions and stops when both hold
where and are the relative and absolute tolerance parameters [22].
The value of determines the convergence rate, and adaptive algorithms help reduce the number of iterations by scaling based on the residuals [17], [26]
thereby eliminating the need to hand-tune and driving the residuals to a comparable magnitude, with the safeguards , .
Remark 2 (Over-relaxation). A standard empirical accelerator is over-relaxation, which substitutes with in the - and -updates. Convergence is retained for , and improves the linear rate at no per-iteration cost [26].
-update as Independent LQT Invocations
Under the split (32), the -update step (28a) keeps the lifted dynamics (9) as equality constraint,
here, . For all the columns, the added penalty term is a sum of squares of components of that acts on column-wise, without any cross-column coupling. Hence, -update (36) splits into independent instances of LQT solves (16), consisting of one mean channel and stochastic channels .
Hence, the defined operators can be used to solve this step with the arguments described in this subsection and summarized in Table II.
| mean channel | stochastic channel | |
| (26) | ||
| (26) | ||
| count | ||
| P-RIC calls / update | , shared | |
| P-LQT calls / iteration | , batched |
Table II. P-RIC and P-LQT arguments with shared .
Quadratic data. Collecting the base cost and the -penalty gives the augmented stage weights
Here, is an indicator function which is 1 if , otherwise 0. And are the quadratic costs for the state (control) in the mean and stochastic channels. They differ in the quadratic costs because of the different way the chance constraints show up and due to the waypoint costs on the mean. Additionally, the terminal covariance constraint only shows up for the stochastic channels.
Linear data. The ADMM target enters only through linear terms, and differs across each of the stochastic channel. Let the scalar and vector parts of the cone be denoted by , and let be the target of the terminal ball. To obtain the linear terms, , the penalty in (36) together with the two reference-tracking terms of (14a) is expanded:
Dynamics data. The dynamics equations are shared as described for the stochastic channels in (25) with different initial conditions (26), and for the mean channels as defined in (9a).
Invocation. The first step in -update is evaluated as parallel Riccati scans:
followed by affine recurrences scans that use the same feedback gains for the stochastic channels:
, where (40) is evaluated only when changes, and
Hence, SOCX solves LQT many times with shared gains, rather than formulating a single large conic program.
-update as Parallel Projections
In the minimization problem of -update, when the cost (38) is a sum of indicators, the update reduces to the proximal operator of the individual indicator, i.e. the Euclidean projection,
The projections are executed in parallel because the sets are independent; i.e., no variable is projected in both sets simultaneously.
Second-order cone constraints. For the projection to the set , we obtain
Therefore, each of , similarly for , is updated as:
here, is as defined in (36) and is the corresponding component of .
Terminal covariance constraint. For projection of to the set , the standard approach is computing the singular value decomposition of and then with denoting an element-wise minimum of the two diagonal matrices. However, as is a fat matrix and we don’t require the matrix , we can instead compute the eigendecomposition of , giving us and , from which we construct . Therefore, the projection operator becomes:
Hence, the update is
Hence, the -update reduces to closed-form Euclidean projections onto the cone and covariance constraint considered, which can be evaluated in a parallel, batched process.
Numerical Simulations
In this section, we present numerical simulations with ablations, run on a system with an Intel Core Ultra 9 285K (64GB RAM) and an RTX 5080 (16GB VRAM). To demonstrate the efficacy of SOCX, we consider a hover-linearized quadrotor with state , inputs , and noise entering as forces and torques, with Euler discretization and . We consider three different setups: a helix in a tapering corridor (13 waypoints), a zig-zag climb, and an out-and-back (4 waypoints each), shown in Figure 2. At , we reduce the waypoints to 3, 2, and 2, respectively, as the 4-s horizon is too short to fly through all of them.

Figure 2. 3D quadrotor trajectories computed with socx, with random wrench perturbations, chance constraints on position & actuator limits and terminal covariance constraint (, , , , ).
The walls are represented as six half-plane linear chance constraints (2) in position , and actuator limits are imposed as both an upper and lower limit with at each time step. The terminal state has a position-covariance constraint (4) with . A selector matrix of appropriate size can be introduced to impose such a terminal covariance constraint. A quadratic penalty on state and control input is imposed. The waypoint and goal terms act only on the mean state.
SOCX vs. MOSEK vs. SCS+cuDSS: Tolerance vs. Solve Time
For baseline comparisons, we report the internal solve times of MOSEK [21] and SCS (cuDSS), both called through CVXPY [27]. SOCX’s measured time excludes JAX’s just-in-time (JIT) compilation [24]. Figure 3 and Table III compare the solve times. Compared to MOSEK, the speed-up grows from 7.2–7.9× at to 57–98× at $N=240 because MOSEK’s time grows faster than SOCX. MOSEK runs out of memory at , while SOCX solves in 145 s on average. As MOSEK is an interior-point method, its solve time does not vary much with tolerance, unlike socx which is a first-order method. We observe that socx remains faster at tight tolerances, but by a smaller margin. At the speed-up is 37–53× at and still 12–14× at . SCS (cuDSS), a GPU-based first-order method, is 47–2224× slower than socx and slower than MOSEK for . We additionally observe that SCS times out at a 10,000s time cap for . In Table III, denotes the probability of violation divided by the allowed violation. A value close to 1 indicates that the constraints are active, and a value greater than 1 quantifies the violation.
Figure 3. Solve time vs. (a) tolerance at fixed and (b) horizon at fixed
-update: LQT ablations
Table IV compares the per-iteration cost of the parallel LQT update with three alternatives. Sequential Riccati updates have span and use 2.5–4.9× less memory, but are 2.5–4.0× slower. The condensed KKT update uses 3.9–9.5× less memory but is 2.2–7.5× slower, and its time grows 3.9× and 6.4× per doubling of . The key comparison is with a per-column loop that does not exploit the fact that the stochastic columns share and therefore , so the gains cannot be reused (39b). It is 6.9–14.8× slower and uses 4.8–9.7× more memory than the shared-gain update, and both gaps widen as grows.
-update: Covariance ablations
We consider three different ways to project onto the terminal covariance constraint (11). A generic conic solver must lift it to an LMI constraint of size as follows
with and project onto with an eigendecomposition of cost . However, socx works with spectral-norm ball projections using the matrix. We also compare against it by computing the SVD of the full matrix , which has the same asymptotic complexity but a larger constant. In Table IV, the Gram eigendecomposition takes 0.39–0.42 ms per call, nearly independent of over this range; the SVD is 2.4–2.5× slower, and the Schur-complement PSD projection is 22–216× slower, with the gap growing with .
Remark 3. Batching can be used to increase solve throughput at the expense of added latency by solving multiple instances in parallel, which often increases the individual solve time [11, 12, 13].
Conclusion
We presented socx, a GPU-accelerated JAX implementation for solving linear stochastic optimal control with exact representations for linear chance constraints and terminal covariance constraints, with approximate representations for quadratic chance constraints. The proposed solver exploits the structure of the lifted convex representation by using ADMM to split the problem into subproblems that can be solved in closed form. The -update becomes a set of independent linear quadratic tracking problems, and the -update becomes parallel projections. We introduced a spectral ball projection for the terminal covariance constraint to reduce computation time.
The proposed algorithm is validated on a 3D hover linearized quadrotor with different waypoint configurations.
| \multicolumn{4}{c}{socx (Ours), GPU} | \multicolumn{2}{c}{MOSEK, CPU} | \multicolumn{2}{c}{SCS+cuDSS, GPU} | |||||||
| time (s) | iterations | obj. err. | time (s) | speed-up | time (s) | speed-up | |||
| 40 | 252 | 1.000 | – | – | |||||
| 80 | 492 | 1.000 | – | – | |||||
| 160 | 972 | 1.002 | – | – | |||||
| 240 | 1,452 | 1.002 | – | – | |||||
| 320 | 1,932 | – | 1.000 | out of memory (50GB cap) | – | ||||
| 1120 | 6,732 | – | – | out of memory (50GB cap) | time out (10,000s cap) |
Table 3. 3D quadrotor at tolerance : mean max. deviation over the three setups of Figure 2.
| Variant | \multicolumn{3}{c}{time (ms)} | \multicolumn{3}{c}{scratch memory (MB)} | complexity | ||||
| 160 | 320 | 160 | 320 | ||||
| -update: per iteration | |||||||
| Parallel LQT (Ours) | 1.13 | 2.62 | 8.17 | 39 | 124 | 390 | |
| Sequential LQT | 4.48 | 9.16 | 20.66 | 8 | 40 | 159 | |
| Condensed KKT | 2.46 | 9.54 | 61.19 | 10 | 13 | 43 | |
| Per-column loop | 7.78 | 30.63 | 120.72 | 188 | 747 | 3768 | |
| Terminal-LMI projection: per call | |||||||
| Gram eigh (Ours) | 0.39 | 0.42 | 0.41 | ||||
| SVD | 0.94 | 1.05 | 0.98 | ||||
| Schur PSD | 8.79 | 22.03 | 88.64 |
Table 4. Ablations on the helix setup at tolerance .
Compared to convex solvers for the same problem, we observe speed-ups of up to compared to MOSEK and compared to SCS at tolerance. The proposed approach can also solve for longer horizons of up to , compared with for the baselines. Additionally, we presented ablations of the -update and the -update to further isolate components of the observed speed-ups.
References
- [1]S. M. LaValle, Planning algorithms. New York: Cambridge University Press, 2006.
- [2]Y. K. Nakka, A. Liu, G. Shi, A. Anandakumar, Y. Yue, and S.-J. Chung, “Chance-Constrained Trajectory Optimization for Safe Exploration and Learning of Nonlinear Systems,” IEEE Robotics and Automation Letters, vol. 6, no. 2, pp. 389–396, Apr. 2021.arxiv.org/abs/2005.04374
- [3]Y. K. Nakka and S.-J. Chung, “Trajectory Optimization for Chance-Constrained Nonlinear Stochastic Systems,” in 2019 IEEE 58th Conference on Decision and Control (CDC), Dec. 2019, pp. 3811–3818.DOI
- [4]Y. K. Nakka and S. J. Chung, “Trajectory optimization of chance-constrained nonlinear stochastic systems for motion planning under uncertainty,” IEEE Transactions on Robotics, vol. 39, no. 1, pp. 203–222, Feb. 2023.arxiv.org/abs/2106.02801
- [5]H. Yu and Y. Chen, “A Gaussian Variational Inference Approach to Motion Planning,” IEEE Robotics and Automation Letters, vol. 8, no. 5, pp. 2518–2525, May 2023.DOI
- [6]F. Liu, G. Rapakoulias, and P. Tsiotras, “Optimal Covariance Steering for Discrete-Time Linear Stochastic Systems,” IEEE Transactions on Automatic Control, vol. 70, no. 4, pp. 2289–2304, Apr. 2025.arxiv.org/abs/2211.00618
- [7]G. Rapakoulias and P. Tsiotras, “Discrete-Time Optimal Covariance Steering via Semidefinite Programming,” in 2023 62nd IEEE Conference on Decision and Control (CDC), Dec. 2023, pp. 1802–1807.arxiv.org/abs/2302.14296
- [8]J. Pilipovsky and P. Tsiotras, “Computationally Efficient Chance Constrained Covariance Control with Output Feedback,” in 2024 IEEE 63rd Conference on Decision and Control (CDC), Dec. 2024, pp. 677–682.arxiv.org/abs/2310.02485
- [9]I. M. Balci and E. Bakolas, “Constrained minimum variance and covariance steering based on affine disturbance feedback control parameterization,” International Journal of Robust and Nonlinear Control, vol. 34, pp. 7332 – 7370, 2024.DOI
- [10]T. Doan and Y. Kumar Nakka, “Exact and approximate convex reformulation of linear stochastic optimal control with chance constraints,” IEEE Control Systems Letters, vol. 10, pp. 787–792, 2026.
- [11]G. Bravo-Palacios, J. Zhang, Z. Pestrikov, B. Plancher, and T. Lew, “Turbompc: Fast, scalable, and differentiable model predictive control on the gpu,” 2026. [Online]. Available: https://arxiv.org/abs/2606.24039
- [12]J. Viljoen, F. Haffner, M. Tomizuka, and N. Mehr, “Scaling nonlinear optimization: Many problems one gpu,” 2026. [Online]. Available: https://arxiv.org/abs/2606.26341
- [13]S. H. Jeon, S. Hong, H. J. Lee, C. Khazoom, and S. Kim, “Cusadi: A gpu parallelization framework for symbolic expressions and optimal control,” IEEE Robotics and Automation Letters, vol. 10, no. 2, pp. 899–906, 2025.arxiv.org/abs/2408.09662
- [14]S. Särkkä and Á. F. García-Fernández, “Temporal parallelization of dynamic programming and linear quadratic control,” IEEE Transactions on Automatic Control, vol. 68, no. 2, pp. 851–866, 2023.DOI
- [15]L. Amatucci, J. Sousa-Pinto, G. Turrisi, D. Orban, V. Barasuol, and C. Gemini, “Primal-dual ilqr for gpu-accelerated learning and control in legged robots,” IEEE Robotics and Automation Letters, vol. 11, no. 1, pp. 1010–1017, 2026.DOI
- [16]K. Okamoto, M. Goldshtein, and P. Tsiotras, “Optimal Covariance Control for Stochastic Systems Under Chance Constraints,” IEEE Control Systems Letters, vol. 2, no. 2, pp. 266–271, Apr. 2018.arxiv.org/abs/1804.02829
- [17]J. Fang and G. Chou, “Safe Large-Scale Robust Nonlinear MPC in Milliseconds via Reachability-Constrained System Level Synthesis on the GPU,” in Proceedings of Robotics: Science and Systems, Sydney, Australia, July 2026.arxiv.org/abs/2604.07644
- [18]J. Wang, A. T. Abdul, and E. Theodorou, “cuNRTO: GPU-Accelerated Nonlinear Robust Trajectory Optimization,” in Proceedings of Robotics: Science and Systems, Sydney, Australia, July 2026.arxiv.org/abs/2603.02642
- [19]Y. Chen, D. Tse, P. Nobel, P. Goulart, and S. Boyd, “Cudacable: Gpu acceleration for a conic optimization solver,” 2024. [Online]. Available: https://arxiv.org/abs/2412.19027
- [20]B. O’Donoghue, E. Chu, N. Parikh, and S. Boyd, “Conic optimization via operator splitting and homogeneous self-dual embedding,” Journal of Optimization Theory and Applications, vol. 169, no. 3, pp. 1042–1068, June 2016. [Online]. Available: http://stanford.edu/~boyd/papers/scs.htmlarxiv.org/abs/1312.3039
- [21]MOSEK ApS, MOSEK Optimizer API for Python 11.2.7, 2025. [Online]. Available: https://docs.mosek.com/11.2/pythonapi/index.html
- [22]M. Schubiger, G. Banjac, and J. Lygeros, “GPU acceleration of ADMM for large-scale quadratic programming,” Journal of Parallel and Distributed Computing, vol. 144, pp. 55–67, 2020.DOI
- [23]A. Mesbah, “Stochastic model predictive control: An overview and perspectives for future research,” IEEE Control Systems Magazine, vol. 36, no. 6, pp. 30–44, 2016.DOI
- [24]J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, Y. Katariya, C. Leary, D. Maclaurin, G. Necula, A. Paszke, J. VanderPlas, S. Wanderman-Milne, and Q. Zhang, “JAX: composable transformations of Python+NumPy programs,” 2018. [Online]. Available: http://github.com/jax-ml/jax
- [25]G. Belloch, “Scans as primitive parallel operations,” IEEE Transactions on Computers, vol. 38, no. 11, pp. 1526–1538, 1989.
- [26]S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein, “Distributed optimization and statistical learning via the alternating direction method of multipliers,” Foundations and Trends in Machine Learning, vol. 3, no. 1, pp. 1–122, 07 2011. [Online]. Available: https://doi.org/10.1561/2200000016
- [27]S. Diamond and S. Boyd, “CVXPY: A Python-embedded modeling language for convex optimization,” Journal of Machine Learning Research, vol. 17, no. 83, pp. 1–5, 2016.
