Convex-Concave Quadratic Programming

• Convex-concave quadratic programming is defined by splitting quadratic functions into convex and concave parts, forming a DC structure for complex optimization.
• Recent methods utilize spectral decomposition, sequential convexification, and convex relaxations (e.g., SOCP, SDP, DNN) to address NP-hard nonconvex problems.
• Applications in finance, control, and signal processing benefit from global optimization techniques like branch-and-bound, ensuring scalable and effective solutions.

Convex-concave quadratic programming (often abbreviated as QCQP in the nonconvex regime) concerns the analysis and solution of optimization problems in which the objective and/or constraints are quadratic functions represented as a difference of convex (DC) terms. These programs arise widely in operations research, control, signal processing, portfolio optimization, and statistical inference. The interplay between convex and concave quadratic terms renders such problems challenging, as global optimality is typically NP-hard. Recent advances combine spectral decomposition, convex relaxations (e.g., SOCP, SDP, DNN), sequential convexification, and structured branch-and-bound to yield tractable algorithms with global convergence guarantees in structured settings.

1. Formal Definition and Mathematical Structure

Consider the general QCQP with possibly multiple quadratic constraints: $$\begin{array}{ll} \min_{y \in D} & f(y) = y^\top Q_0 y + q_0^\top y + c_0 \ \text{s.t.} & g_i(y) = y^\top Q_i y + q_i^\top y + c_i \le 0, \quad i=1,2,\ldots,k \ & y \in D \end{array}$$ where $Q_i$ are real symmetric matrices, the feasible set $D$ is frequently a polyhedron, and each $g_i(y)$ encodes quadratic constraints. The structure is nonconvex when any $Q_i$ are indefinite. By spectral decomposition, any quadratic form $y^\top Q y$ can be split into a convex ($Q^+\succeq 0$) and concave ($Q^-\succeq 0$) component: $$Q = Q^+ - Q^- \implies y^\top Q y = y^\top Q^+ y - y^\top Q^- y$$ Thus, the objective and constraints can each be represented as a DC function, providing a foundation for DC-programming approaches (Yin, 2023, Shen et al., 2016).

2. Algorithmic Approaches: DC Splitting, Linearization, and Sequential Convexification

Modern algorithms decompose convex-concave quadratics into convex parts (retained exactly) and concave parts (iteratively linearized). The Successive Convex Optimization (SCO) framework operates as follows (Yin, 2023):

• At each iterate $u$, concave quadratic terms $Q_i$0 are upper-bounded by their first-order Taylor expansion at $Q_i$1:

$Q_i$2

• This yields a new surrogate problem that is a convex QP, efficiently solvable with standard algorithms.
• Monotonic decrease of the original objective is guaranteed at each SCO step.

The Convex-Concave Procedure (CCP), as formalized in the DCCP framework (Shen et al., 2016), operates similarly:

• Each concave term is replaced by its affine tangent,
• The resulting problem is convex and can be addressed with off-the-shelf solvers,
• Iterates remain feasible for the original domain through domain-indicator constraint handling,
• The algorithm converges to stationary points (but not globally optimal solutions in the nonconvex case),
• Slack variables or penalty terms are included to safeguard feasibility and manage nondifferentiability.

Hybrid CCP-based Sequential Quadratic Programming (CCP-SQP), applicable in temporal logic control, decomposes specification robustness into convex max and concave smooth-min nodes, linearizing only the concave terms and generating QP subproblems with affine and quadratic structure (Takayama et al., 2023).

3. Global Optimization: Convex Relaxation, Branch-and-Bound, and Envelopes

Achieving global optimality for QCQPs requires bounding and relaxation techniques:

• McCormick envelopes (Yin, 2023): Over a box $Q_i$3, concave quadratic forms are overapproximated by affine upper bounds, resulting in convex QP relaxations. The tightness of these relaxations controls the gap between lower and upper bounds.
• Convex hull and SOCP relaxations (Santana et al., 2018): The exact convex hull of a quadratic equality or single constraint over a bounded polytope is second-order cone representable (SOCr). This provides tight SOCP relaxations for nodes in branch-and-bound solvers, often outperforming basic SDP relaxations in practical convergence and scalability.
• Doubly-Nonnegative (DNN) SDP relaxations (Qu et al., 2023): By lifting the problem to a matrix variable $Q_i$4, enforcing $Q_i$5, and requiring positive semidefiniteness and elementwise non-negativity, one obtains the DNN relaxation. This relaxation is equivalent in strength to the Shor SDP relaxation for the reference-value problem, and—under bounded polyhedral constraints—enables branch-and-cut frameworks with provably finite convergence and zero duality gap.
• Branch-and-bound (B&B): Used in practice for global nonconvex QCQPs (Yin, 2023, Santana et al., 2018). Each node relaxes the nonconvex problem via convex surrogates above; subproblems are split ("branched") over variable domains; upper/lower bounds facilitate early pruning. Advanced bounding (SOCr, SDP, McCormick) tightens node relaxations, improving efficiency.

4. Saddle-Point Theory and Convex–Concave Quadratic Game Structure

Convex–concave quadratic programs arise as saddle-point problems in two-player zero-sum games and weakly coupled control. The canonical structure is (Melcher et al., 13 Oct 2025): $Q_i$6 with $Q_i$7, $Q_i$8.

Melcher, Jalilzadeh, and Hamedani introduce "two-sided quadratic functional growth" (QFG) and "two-sided quadratic gradient growth" (QGG), generalizing strong convexity/concavity to allow for linear convergence of primal–dual GAPD algorithms even in the absence of strict convexity (Melcher et al., 13 Oct 2025). For QPs, the iterates exhibit closed-form updates, and error contracts by a factor $Q_i$9 determined by the problem's spectral properties.

5. Computational Methods and Software Implementations

Efficient implementation of convex-concave QCQP solvers is supported through a mixture of algorithmic and software strategies:

• The DCCP package extends CVXPY for disciplined modeling and solution of CCP/DC programs, automatically handling domain issues, linearization, and feasibility (Shen et al., 2016). Problems are specified via standard mathematical syntax and solved through sequential convex subproblems.
• In message-passing contexts (MAP inference in graphical models), the CCCP framework yields tractable algorithms via explicit DC decomposition of quadratic cost terms, yielding competitive local and convex-relaxation solutions compared to CPLEX, max-product algorithms, and variants (Kumar et al., 2012).
• Branch-and-bound solvers leveraging convex hull construction or DNN relaxations (e.g., QuadProgCD) exhibit empirical scaling to $D$0+ instances at variable dimension $D$1, with substantial computational improvements over commercial solvers on nonconvex quadratic settings (Qu et al., 2023, Yin, 2023).
• Recent advances exploit the structure of temporal logic specifications to exploit block-separability, leading to efficient CCP-SQP implementations for control applications (Takayama et al., 2023).

6. Theoretical Guarantees and Empirical Performance

• Convergence: Sequential convexification approaches guarantee monotonic decrease and feasibility of iterates at every step; limit points are stationary for the DC program, but global optimality is only guaranteed in the convex relaxation case (Yin, 2023, Shen et al., 2016, Takayama et al., 2023).
• Globality: Branch-and-bound frameworks with exact convex envelope relaxations, such as McCormick or convex hull SOCP, provably attain $D$2-optimality in finite steps (Yin, 2023, Santana et al., 2018).
• Rates: In convex–concave quadratic saddle-point settings with quadratic growth, GAPD iterates yield provably linear convergence in terms of spectral constants (Melcher et al., 13 Oct 2025).
• Scalability: Empirical studies report that global solvers combining DNN/SDP/McCormick relaxations with cut-generation, domain partitioning, and convexification outperform both general-purpose commercial solvers (CPLEX, Gurobi) and naive sequential QP approaches in high dimensions (Qu et al., 2023, Yin, 2023).
• Quality of solutions: In nonconvex regimes, CCP-based solvers frequently recover high-quality local optima, sometimes matching global objective values while executing orders of magnitude faster than exact methods (e.g., in Boolean least squares and MAP inference) (Kumar et al., 2012, Shen et al., 2016).

7. Applications and Broader Impact

Convex–concave quadratic programming occupies a central role in modern optimization and its applications:

• Financial portfolio optimization under multiple risk/quadratic constraints (Yin, 2023);
• Control synthesis for systems with temporal logic specifications (Takayama et al., 2023);
• MAP inference in graphical models with pairwise interactions (Kumar et al., 2012);
• Nonconvex regression and statistical learning problems;
• Structural engineering, circuit design, and resource allocation scenarios.

The advances in convexification techniques (SOCP hulls, DNN relaxations, McCormick envelopes), efficient branch-and-bound algorithms, and scalable heuristic procedures (CCP/SCO) have expanded the range and scale of convex-concave QPs that are tractable in practice. The field remains active with ongoing development of sharper bounds, accelerated primal-dual methods, and domain-specific decomposition exploiting problem structure.