PDCS: Primal-Dual Conic Solver

• PDCS is a first-order, matrix-free solver for large-scale conic programming, supporting LPs, SOCPs, convex QPs, and exponential cone problems.
• It employs a restarted PDHG method with adaptive step-size selection, reflected Halpern restarts, and diagonal rescaling to enhance convergence and robustness.
• Empirical studies show PDCS excels in sparse, large-scale applications like Fisher markets, Lasso regression, and portfolio optimization compared to traditional solvers.

Primal-Dual Conic Programming Solver (PDCS) is a first-order, matrix-free solver for large-scale conic optimization problems. It was introduced as a primal-dual large-scale conic programming solver with GPU enhancements and is built around the restarted primal-dual hybrid gradient method, augmented by adaptive reflected Halpern restarts, adaptive step-size selection, adaptive weight adjustment, diagonal rescaling, and bijection-based projection onto rescaled cones (Lin et al., 1 May 2025). A subsequent technical note documents the implementation and use of PDCS, including its CPU and GPU backends, solver options, and interfaces with JuMP and CVXPY (Lin et al., 16 Mar 2026).

1. Mathematical formulation and conic scope

PDCS solves conic programs of the form

$$\min \ \langle c,x\rangle \quad \text{s.t. } Gx-h \in K,\; l \le x \le u,\; x \in K_p,$$

where $G \in \mathbb{R}^{m\times n}$, $c \in \mathbb{R}^n$, $h \in \mathbb{R}^m$, $l,u$ are componentwise lower and upper bounds on a subset of variables, $K$ is a primal cone, and $K_p$ is the cone on the primal variable block (Lin et al., 16 Mar 2026). In the 2025 presentation, the same solver family is written in a closely related form,

$$\min_{x=(x_1,x_2)} \langle c,x\rangle \quad \text{s.t.}\quad Gx-h\in \mathcal K_d^*,\; l\le x_1\le u,\; x_2\in \mathcal K_p,$$

with the feasible region defined by a product of cones and bound constraints (Lin et al., 1 May 2025).

The cone $K$ is assumed to be a Cartesian product of basic cone blocks. The technical note states that PDCS supports blocks including the zero cone $\{0\}$, the nonnegative orthant $G \in \mathbb{R}^{m\times n}$0, the second-order cone, the exponential cone $G \in \mathbb{R}^{m\times n}$1, the rotated second-order cone, and the dual exponential cone (Lin et al., 16 Mar 2026). The main paper emphasizes the currently supported problem classes: linear programs, second-order cone programs, convex quadratic programs via SOCP reformulations, and exponential cone programs (Lin et al., 1 May 2025).

This formulation places PDCS in the general conic-programming setting rather than in the narrower LP-only or QP-only regime. The main paper explicitly treats LPs, SOCPs, convex QPs, and exponential-cone models as target classes, which covers applications such as Fisher market equilibrium problems, Lasso regression, and multi-period portfolio optimization (Lin et al., 1 May 2025).

2. Saddle structure and the PDHG kernel

PDCS is organized around the primal-dual saddle formulation

$G \in \mathbb{R}^{m\times n}$2

with

$G \in \mathbb{R}^{m\times n}$3

so that a saddle point $G \in \mathbb{R}^{m\times n}$4 corresponds to an optimal primal solution $G \in \mathbb{R}^{m\times n}$5 and an optimal dual solution $G \in \mathbb{R}^{m\times n}$6 (Lin et al., 16 Mar 2026). The main paper presents the same convex-concave structure as

$G \in \mathbb{R}^{m\times n}$7

with $G \in \mathbb{R}^{m\times n}$8 and $G \in \mathbb{R}^{m\times n}$9 (Lin et al., 1 May 2025).

The core iteration is a PDHG step. With primal step size $c \in \mathbb{R}^n$0 and dual step size $c \in \mathbb{R}^n$1, PDCS computes

$c \in \mathbb{R}^n$2

$c \in \mathbb{R}^n$3

This is the extrapolated PDHG or Chambolle-Pock update used as the solver’s base mechanism (Lin et al., 16 Mar 2026). The main paper gives the same update in the notation

$c \in \mathbb{R}^n$4

and identifies sparse matrix-vector multiplication with $c \in \mathbb{R}^n$5 and $c \in \mathbb{R}^n$6 and projection onto cones as the essential per-iteration primitives (Lin et al., 1 May 2025).

PDCS monitors primal feasibility, dual feasibility, and primal-dual gap through absolute and relative error quantities. The technical note defines absolute errors for the primal constraint residual, the dual residual, and the primal-dual gap, and then relative errors normalized by $c \in \mathbb{R}^n$7, $c \in \mathbb{R}^n$8, and $c \in \mathbb{R}^n$9, respectively (Lin et al., 16 Mar 2026). The main paper summarizes the same monitoring strategy through

$h \in \mathbb{R}^m$0

which functions as the solver’s aggregate optimality indicator (Lin et al., 1 May 2025).

3. Adaptive acceleration, restart, and primal-dual balancing

The distinctive features of PDCS lie in the mechanisms wrapped around the base PDHG iteration. The technical note lists five enhancements: adaptive step-size selection, adaptive reflected Halpern iteration, adaptive restart, primal weight updates, and diagonal preconditioning or rescaling (Lin et al., 16 Mar 2026). The main paper groups the same ideas under adaptive step-size selection, adaptive reflected Halpern restarts, adaptive restart, and adaptive primal weight adjustment (Lin et al., 1 May 2025).

For step-size selection, PDCS parameterizes the primal and dual steps by a primal weight $h \in \mathbb{R}^m$1 and a scalar $h \in \mathbb{R}^m$2,

$h \in \mathbb{R}^m$3

and adapts $h \in \mathbb{R}^m$4 by a line-search heuristic inspired by PDLP (Lin et al., 16 Mar 2026). This removes the need to rely exclusively on conservative worst-case choices such as $h \in \mathbb{R}^m$5, while retaining the PDHG structure (Lin et al., 16 Mar 2026).

After the raw PDHG update, PDCS applies a reflected Halpern iteration. The main paper writes the update as

$h \in \mathbb{R}^m$6

anchoring the current inner-loop dynamics at the restart point $h \in \mathbb{R}^m$7 while also extrapolating through the reflection term (Lin et al., 1 May 2025). The reflection coefficient is selected adaptively as

$h \in \mathbb{R}^m$8

so that the method is more conservative when residuals are large and more aggressive as residuals shrink (Lin et al., 1 May 2025).

Adaptive restart is based on the normalized duality gap

$h \in \mathbb{R}^m$9

or, in practice, a diagonal-surrogate approximation $l,u$0 computed efficiently by bisection (Lin et al., 16 Mar 2026). Restart is triggered by sufficient decay, necessary decay combined with lack of local progress, or a hard cap on the inner-loop length (Lin et al., 16 Mar 2026). For cones such as exponential and second-order cones, the note states that normalized duality-gap computation can become numerically delicate; in that case PDCS switches to a fallback criterion based on a weighted KKT error,

$l,u$1

in the technical-note notation (Lin et al., 16 Mar 2026).

The primal weight $l,u$2 is updated only at restarts. It balances the relative scale of primal and dual motion, and the technical note reports instability when $l,u$3 or $l,u$4, in which case the solver resets it to its initial value (Lin et al., 16 Mar 2026). In the main paper, the initialization rule is

$l,u$5

when both norms exceed $l,u$6, and $l,u$7 otherwise (Lin et al., 1 May 2025).

4. Rescaled cone projections, software realization, and GPU implementation

A major implementation layer in PDCS is diagonal rescaling. The technical note writes the rescaled matrix as

$l,u$8

with positive diagonal matrices $l,u$9, and transforms the conic program accordingly (Lin et al., 16 Mar 2026). The main paper gives the corresponding transformed data

$K$0

together with transformed cones $K$1 and $K$2 (Lin et al., 1 May 2025). The stated purpose is conditioning improvement without loss of sparsity.

Rescaling complicates projection because transformed cones are no longer always standard. PDCS therefore uses bijection-based root-finding methods to compute projections onto rescaled cones (Lin et al., 1 May 2025). For the rescaled second-order cone, projection is reduced to a scalar root-finding problem. For the rescaled exponential cone, the main paper uses Moreau decomposition and parameterizes the projection by a scalar $K$3, again leading to a bijection search (Lin et al., 1 May 2025). The technical note states that, for general cones, projections onto transformed cones can still be reduced to efficient root-finding procedures and identifies this point as especially important for second-order and exponential cones (Lin et al., 16 Mar 2026).

The GPU implementation, cuPDCS, is designed to keep as much computation on the GPU as possible and to reduce CPU-GPU transfers (Lin et al., 1 May 2025). The main paper describes three levels of parallelization for cone projection: grid-wise, block-wise, and thread-wise. It further states that zero, nonnegative, and exponential cone projections are cheap and work well with thread-wise parallelism, whereas SOCP projection may use thread-wise, block-wise, or grid-wise strategies depending on workload size (Lin et al., 1 May 2025). This architectural specialization is directly tied to the solver’s stated emphasis on sparse matrix-vector multiplication as the core computational operation.

PDCS is publicly available at https://github.com/ZikaiXiong/PDCS under the Apache License 2.0 (Lin et al., 16 Mar 2026). The technical note documents three interfaces—JuMP, CVXPY, and a direct Julia API—and recommends the GPU backend whenever possible (Lin et al., 16 Mar 2026). It also states that the CVXPY interface currently supports the GPU backend only (Lin et al., 16 Mar 2026).

5. Empirical behavior and application domains

The main paper reports experiments on CBLIB benchmark problems, Fisher market equilibrium problems, Lasso problems, and multi-period portfolio optimization problems (Lin et al., 1 May 2025). Its headline empirical claim is that cuPDCS is generally more efficient than state-of-the-art commercial solvers and other first-order methods on large-scale conic program applications, and that it exhibits better scalability, efficiency, and robustness than other first-order methods on CBLIB, with the advantages more pronounced in large-scale, lower-accuracy settings (Lin et al., 1 May 2025).

The performance profile is not uniform across scales. On the mostly small-scale CBLIB benchmark, barrier or interior-point methods are usually much faster, but cuPDCS is reported to be more stable than other first-order methods and often competitive or better on medium and large instances (Lin et al., 1 May 2025). In Fisher market equilibrium, an exponential-cone application, cuPDCS beats SCS(GPU), is often competitive with or better than COPT and MOSEK on large instances, becomes particularly strong when the number of nonzeros grows beyond roughly $K$4 to $K$5, and is especially good at low accuracy (Lin et al., 1 May 2025).

For Lasso reformulated as SOCP, the main paper states that cuPDCS is the best performer across all tested solvers, including commercial and GPU barrier solvers, and remains effective up to $K$6 (Lin et al., 1 May 2025). It also notes that runtime increases only modestly when tightening tolerance from $K$7 to $K$8, and that nearly linear convergence is observed empirically on this class (Lin et al., 1 May 2025). In multi-period portfolio optimization, cuPDCS consistently outperforms SCS(indirect) and ABIP, is more scalable than interior-point methods on large instances, and continues to run effectively when MOSEK* becomes memory-limited for large horizons (Lin et al., 1 May 2025).

The technical note frames these results in operational terms. It identifies PDCS as especially attractive for large-scale conic optimization problems with millions of variables and constraints, where interior-point methods are typically too memory-intensive, and recommends keeping preconditioning, adaptive step-size selection, and adaptive restart enabled (Lin et al., 16 Mar 2026). A plausible implication is that PDCS is intended primarily for throughput-oriented conic workloads rather than for the fastest possible high-accuracy termination on small to medium instances.

6. Position within the conic-solver landscape

PDCS belongs to the first-order primal-dual branch of conic optimization. Its immediate algorithmic ancestry is PDHG, but the technical note explicitly positions it in the same family as PDLP, cuPDLP, cuPDLP-C, HPR-LP, and rHPDHG, while extending the restarted-PDHG idea from LPs to more general conic settings (Lin et al., 16 Mar 2026). This distinguishes it from homogeneous self-dual embedding solvers such as the ADMM-based method of O’Donoghue, Chu, Parikh, and Boyd, which solves a cone-subspace feasibility problem and is designed to return either primal-dual solutions or certificates of infeasibility or unboundedness (O'Donoghue et al., 2013).

Within first-order conic methods, PDCS is related in spirit to projection-based primal-dual schemes such as PIPG and xPIPG. PIPG is a first-order primal-dual method for conic optimization that guarantees $K$9 convergence of both primal-dual gap and constraint violation in the general convex case, improves the primal-dual gap to $K_p$0 under strong convexity, and improves the constraint violation to $K_p$1 (Yu et al., 2021). xPIPG extends this line by adding extrapolation and automatic infeasibility detection, with iterates that either satisfy primal-dual optimality conditions asymptotically or generate proofs of primal or dual infeasibility (Yu et al., 2022). PDCS differs by emphasizing restarted PDHG, adaptive reflection, diagonal rescaling, and GPU-oriented cone-projection kernels rather than the specific update and certificate machinery of PIPG-type methods.

The principal contrast is with interior-point methods. Recent work on asymmetric long-step primal-dual IPMs with dual centering targets conic optimization problems for which the dual formulation is simpler than the primal one and retains best-known polynomial-time complexity bounds while using only Cholesky factorization (Nesterov, 13 Mar 2025). Separate 2025 results sharpen the complexity analysis of symmetric primal-dual interior-point algorithms by proving exact and asymptotically tight bounds on a key scaling measure, which in turn implies the standard $K_p$2 iteration complexity for broad classes of primal-dual IPMs (Dahl et al., 12 Sep 2025). Against that background, PDCS occupies the matrix-free, sparse-linear-algebra end of the solver spectrum. This suggests a division of labor: interior-point solvers remain the reference approach for rapidly reaching high accuracy, whereas PDCS is designed for very large sparse conic programs in which sparse matrix-vector multiplication, cone projection, restart heuristics, and GPU execution dominate the practical cost model.