PDLP: A Practical First-Order Method for Large-Scale Linear Programming

We present PDLP, a practical first-order method for linear programming (LP) designed to solve large-scale LP problems. PDLP is based on the primal-dual hybrid gradient (PDHG) method applied to the minimax formulation of LP. PDLP incorporates several enhancements to PDHG, including diagonal preconditioning, presolving, adaptive step sizes, adaptive restarting, and feasibility polishing. Our algorithm is implemented in C++, available in Google’s open-source OR-Tools library, and supports multithreading. To evaluate our method, we introduce a new collection of eleven large-scale LP problems with sizes ranging from 125 million to 6.3 billion nonzeros. PDLP solves eight of these instances to optimality gaps of 1% (with primal and dual feasibility errors of less than $10^{-8}$) within six days on a single machine. We also compare PDLP with Gurobi barrier, primal simplex, and dual simplex implementations. These traditional methods are designed to solve linear programs to much tighter optimality gaps but struggle to solve these instances. Gurobi barrier solves only three instances, exceeding our 1TB RAM limit on the other eight. While primal and dual simplex are more memory-efficient than the barrier method, they are slower and solve only three instances within six days. Compared with the conference version of this work (in: Advances in Neural Information Processing Systems 34 (NeurIPS 2021)), the key new contributions are: (i) feasibility polishing, a technique that quickly finds solutions that are approximately optimal but almost exactly feasible (without which only two of the eleven problems can be solved); (ii) a multithreaded C++ implementation available in Google OR-Tools; and (iii) a new collection of large-scale LP problems. Note that the conference version should be referred to for comparisons with SCS and ablation studies, which we do not repeat in this paper.

💡 Research Summary

The paper introduces PDLP, a practical first‑order algorithm for solving extremely large linear programming (LP) problems. PDLP builds on the primal‑dual hybrid gradient (PDHG) method, which is an operator‑splitting technique that updates primal and dual variables via simple matrix‑vector multiplications. While PDHG is attractive for its low per‑iteration cost and memory‑friendly matrix‑free nature, naïve application to LP suffers from slow convergence and, more critically, from infeasibility or dual‑infeasibility that makes the solutions unusable in practice.

To overcome these limitations the authors augment PDHG with four key enhancements: (1) diagonal preconditioning that automatically rescales each primal and dual variable to balance Lipschitz constants, thereby stabilizing step‑size selection; (2) a presolving phase that removes redundant rows/columns, fixes variables, and otherwise reduces the effective problem dimension; (3) adaptive step‑size rules together with a restart mechanism that detects stagnation and re‑initializes the algorithm, preserving a provable linear convergence rate; and (4) a novel feasibility‑polishing stage that, after a coarse solution is obtained, solves a small auxiliary problem to drive primal and dual residuals down to machine‑precision levels (≤ 10⁻⁸) while keeping the objective within a modest 1 % gap. The polishing step is essential: without it only two of the eleven test instances would meet the prescribed tolerances.

Implementation details are significant. The algorithm is written in C++ and released as part of Google’s open‑source OR‑Tools library. It exploits multithreading (via OpenMP) to parallelize the dominant sparse matrix‑vector products, allowing the method to run on a single commodity server with up to 1 TB of RAM. Memory usage remains comparable to the baseline PDHG because the method never forms or factorizes any dense matrices; it only stores the sparse constraint matrix and a few auxiliary vectors.

The experimental section introduces a new benchmark suite of eleven LP problems ranging from 125 million to 6.3 billion non‑zero entries. These instances stem from real‑world domains such as power‑grid unit commitment, large‑scale network flow, and PageRank‑type optimization. PDLP solves eight of the eleven instances to the target criteria (≤ 1 % optimality gap and ≤ 10⁻⁸ primal/dual infeasibility) within six days. By contrast, Gurobi’s barrier interior‑point method hits the 1 TB memory ceiling on eight problems and solves only three; both Gurobi’s primal and dual simplex solvers are more memory‑efficient but slower, also solving only three instances in the same time budget. The authors emphasize that the feasibility‑polishing enhancement alone accounts for the dramatic difference between solving two versus eight instances.

The paper also situates PDLP within the broader theoretical landscape. Prior work has shown that PDHG applied to LP enjoys a linear convergence rate, and that restarts can achieve the worst‑case lower bound on that rate. Recent analyses provide condition‑number‑free complexity bounds for totally unimodular LPs, and a two‑stage behavior (active‑set identification followed by homogeneous inequality solving) that explains slower convergence near degenerate solutions. The authors reference these results and note that ongoing research is integrating central‑path‑based preconditioners and Halpern iteration acceleration, promising further speedups.

In summary, PDLP demonstrates that a carefully engineered first‑order method can rival traditional second‑order commercial solvers on ultra‑large sparse LPs, delivering acceptable optimality gaps while guaranteeing near‑exact feasibility, all with modest memory footprints and straightforward parallelism. The open‑source C++ implementation makes the technique readily available to practitioners, and the paper’s new benchmark suite provides a valuable testbed for future algorithmic advances in large‑scale linear optimization.