Quadratic Optimization Through the Lens of Adjustable Robust Optimization

Published Online:https://doi.org/10.1287/ijoc.2024.0577

Abstract

Quadratic optimization (QO) has been studied extensively in the literature due to its applicability in many practical problems. Although practical, it is known that QO problems are generally NP-hard. Therefore, researchers developed many approximation methods to find good solutions. In this paper, we analyze QO problems using robust optimization techniques. To this end, we first show that any QO problem can be reformulated as a disjoint biconvex QO problem. Then, we provide an equivalent adjustable robust optimization (ARO) reformulation and leverage the methods available in the literature on ARO to approximate this reformulation. More specifically, we show that using a so-called decision rule technique to approximate the ARO reformulation is equivalent to using a reformulation-linearization technique on the original QO problem. Additionally, we design an algorithm that can find a close-to-optimal solution based on our new reformulations. Our numerical results demonstrate the efficiency of our algorithm to find near-optimal solutions, particularly for large-sized instances, compared with off-the-shelf solvers and state-of-art approaches.

History: Accepted by Antonio Frangioni, Area Editor for Design & Analysis of Algorithms–Continuous.

Funding: The research of A. Khademi was part supported by a grant from IPM [Grant 1404900034].

Supplemental Material: The software that supports the findings of this study is available within the paper and its Supplemental Information (https://pubsonline.informs.org/doi/suppl/10.1287/ijoc.2024.0577) as well as from the IJOC GitHub software repository (https://github.com/INFORMSJoC/2024.0577). The complete IJOC Software and Data Repository is available at https://informsjoc.github.io/.

1. Introduction

Various practical problems in different domains, including financial mathematics (Markowitz 1952), machine learning (Cevikalp and Polikar 2008), resource allocation (Ibaraki and Katoh 1988), computer vision (Bhanja et al. 2016), game theory (Bomze 2002b), robotic systems (Khadivar et al. 2023), graph theory (Gibbons et al. 1997), and image processing (Bulo et al. 2011), to mention few, can be formulated as quadratic optimization problems. Thus, developing efficient techniques to solve general quadratic optimization problems is of great importance.

Let us consider a quadratic optimization (QO) problem of the form:

minx∈X x⊤Qx+c⊤x,(QO)
where X⊆Rnx is a nonempty convex set, Q∈Rnx×nx is a real matrix, and c∈Rnx is a real vector. Without loss of generality, we assume that Q is a symmetric matrix. If Q is a positive semidefinite matrix, we have a convex QO, which is solvable in polynomial time (Kozlov et al. 1980, Renegar 2001). In contrast, even when Q has only one negative eigenvalue, (QO) is NP-hard (Pardalos and Vavasis 1991). Besides, identifying local minimizers of (QO) over a polyhedron is not simpler than finding global minimizers from a complexity perspective (Ahmadi and Zhang 2022).

Because of the NP-hardness of indefinite QO problems, there has been a lot of research on constructing upper bounds via finding “good” solutions (Bentobache et al. 2022, Cuong et al. 2024) and lower bounds to identify the quality of a candidate solution, which are mainly based on linear or conic approximations (Mitchell et al. 2014, Rostami et al. 2023, Zamani 2023). A customary way to approximate a QO problem is by relaxing it into linear optimization problems, which is achieved through reformulation-linearization techniques (RLTs) (Sherali and Tuncbilek 1995, Anstreicher 2009). For an overview of RLTs, we refer the reader to the chapter by Sherali and Liberti (2009) and the references therein.

Among the conic relaxations, copositive relaxations have been considered the most powerful as it was shown that they result in tight bounds (Burer 2009, Bomze 2015). In such relaxations, the primary computational challenge shifts to deal with the copositive cone using tractable inner and outer approximations (Bundfuss and Dur 2009, Gouveia et al. 2020, Kim et al. 2020), or use a Karush-Kuhn-Tucker (KKT)-based branch-and-bound method (Chen and Burer 2012).

Another important conic relaxation for QO problems is the positive semidefinite relaxations. In the last thirty years, the field of semidefinite optimization (SDO) has undergone significant and swift advancement (Wolkowicz et al. 2012). Because of their efficiency, the SDO framework has led to many semidefinite relaxations; these relaxations are reviewed and compared in Bao et al. (2011), Wang and Kılınç-Karzan (2022), and Zheng et al. (2011). Moreover, Burer and Vandenbussche (2008, 2009) develop branch-and-bound approaches based on semidefinite relaxations to solve a QO problem.

In addition to directly approximating QO problems, a research direction is to reformulate them into other well-studied problems. Hu et al. (2012) and Xia et al. (2020) show how a QO problem is reformulated as a mixed-integer linear optimization (MILO) problem. Furthermore, it is possible to transform an indefinite QO problem with quadratic constraints into a bilinear problem with additional variables and constraints (Hansen and Jaumard 1992). Moreover, because any quadratic function can be written as the difference between two convex quadratic functions, a QO can be reformulated as a difference-of-convex (DC) optimization problem (Anstreicher and Burer 2005, Fampa et al. 2017). For a review of DC optimization, we refer the reader to Horst and Thoai (1999) and Lipp and Boyd (2016).

Next to methods developed for general QO problems, there are techniques to solve or approximate special classes. One class is when the matrix Q has a few negative eigenvalues. In Cen and Xia (2021), the authors propose a solution scheme that involves solving a series of convex QO problems over the original feasible region. Additionally, Luo et al. (2019) introduce an alternative direction-based method to solve QO problems in this class.

Another class is standard QO problems, where the feasible region is the unit simplex. For more details on lower bound approximations for this class of QO problems, we refer the reader to Bomze and De Klerk (2002), Bomze et al. (2008), Bonami et al. (2019), Gökmen and Yıldırım (2022), Gondzio and Yıldırım (2021), and Selvi et al. (2023).

In this paper, we focus on the relation between QO problems and adjustable robust optimization problems. The adjustable robust optimization (ARO) framework, initially introduced in Ben-Tal et al. (2004), has gained significant attention among researchers due to its ability to handle decision-making problems in the presence of uncertain parameters. This approach involves adaptive decision making by considering two types of decision variables: static and adjustable decisions. Static (or “here-and-now”) decisions are made based on available information, whereas adjustable (or “wait-and-see”) decisions are made in response to the actual values of uncertain parameters. In recent years, the ARO framework has been successfully applied to tackle complex optimization problems such as convex maximization, bilinear optimization, and convex-nonconvex quadratic optimization (Bomze and Gabl 2021, Selvi et al. 2022, Zhen et al. 2022).

There are algorithms and approaches developed in the literature to solve an ARO problem exactly. Fourier-Motzkin elimination (FME) is such an approach that can be used in ARO problems with fixed recourse (Zhen et al. 2018). If all adjustable decision variables are eliminated, a static solution can be obtained by solving the robust counterpart. Even if not all adjustable decision variables can be eliminated, the resulting exact reformulation is likely to lead to stronger bounds after applying approximation techniques. Furthermore, there are iterative approaches to solve such problems exactly either by partitioning the uncertainty set (Bertsimas and Dunning 2016, Postek and Hertog 2016) or applying piece-wise decision rules (Thomä et al. 2024).

To obtain an approximate solution for an ARO problem, various techniques, such as the finite scenario approach (Hadjiyiannis et al. 2011), finite adaptability approach (Bertsimas and Caramanis 2010), and decision rules (El Housni and Goyal 2021) can be employed, particularly in the case of linear ARO problems. Using these methods, one can estimate the optimal value or obtain an approximated solution for the original problem. For more information on ARO, we refer to the tutorial by Delage and Iancu (2015) and the survey paper by Yanıkoğlu et al. (2019).

Although there has been a lot of research in approximating linear ARO problems, the literature sparsely covers nonlinear ARO problems due to their inherent complexity. De Ruiter et al. (2023) show a class of nonlinear ARO problems featuring a polyhedral uncertainty set that can be transformed into an equivalent linear ARO problem, thereby enabling the application of the existing approximations techniques for linear cases. In a recent study, Khademi et al. (2024) employed Fenchel’s duality to convert a nonlinear ARO problem into its dual formulation and introduce a cutting-plane algorithm to find locally robust solutions.

In this paper, we make a four-fold contribution to the literature to connect the two fields of quadratic optimization and adjustable robust optimization. First, we show that any QO problem can be reformulated as a disjoint biconvex quadratic optimization problem. Using this new reformulation, we further show that any QO problem can be reformulated as an ARO problem, where the objective functions and constraints are convex quadratic in the decision variables. This structure allows us to employ customary techniques to relax the ARO reformulation, thereby enabling us to derive a near-optimal solution to the original problem.

Second, we show how one can interpret an approximation of the ARO reformulation on the original QO problem. More specifically, we prove that applying a structured affine decision rule to approximate the ARO formulation is equivalent to applying an RLT to approximate the original problem.

Third, we design an algorithm to construct a bound on the optimal value of (QO). More specifically, we apply a decision rule approximation to obtain a lower bound. Then, based on the solution and the structure of the ARO problem, we construct “good” feasible solutions. In the final step, we apply the mountain climbing procedure to improve the quality of the solution.

Finally, we conduct an extensive numerical experiment to illustrate the efficiency of our algorithm in obtaining near-optimal solutions. Based on the numerical results, we see that the solution obtained from the algorithm is close to optimum and, in most cases, has an optimality gap of 1% for concave QO problems (the optimality gap is measured as the percentage relative gap between lower and upper bounds on the optimal value). Regarding speed, our algorithm is computationally efficient and significantly outperforms the available off-the-shelf solvers and state-of-the-art approaches for large-sized instances.

The rest of the paper is structured as follows. In Section 1.1, we define the notation used throughout the paper. Section 2 introduces the reformulation of a QO problem as a biconvex optimization problem and outlines its equivalent ARO problem. In Section 3, we approximate this problem using available techniques and prove the equivalence to an RLT for the original QO problem. Subsequently, in Section 4, we design an algorithm that provides a near-optimal solution for a QO problem using the ARO reformulation. Section 5 presents numerical results, demonstrating the efficiency of our ARO-based algorithm, particularly for large-sized instances. Finally, in Section 6, we summarize our findings and present our conclusions.

1.1. Notation

In this section, we introduce notations used in the paper. For a symmetric matrix B, we use B⪰0 (B≻0) to show B is positive semidefinite (positive definite); that is, it has nonnegative (positive) eigenvalues. The smallest and largest eigenvalues of a symmetric matrix B are denoted by λmin(B) and λmax(B), respectively. For a given matrix B, and indices i and j, we denote by Bi, Bj, and Bij, the ith row, the jth column, and the ijth entry of B, respectively. For a matrix B, vec(B) denotes the vector formed by concatenating all the rows of matrix B. For a square matrix B, diag(B) is a vector containing the main diagonal elements of matrix B. For vector v, Diag(v) is a matrix with the elements of vector v placed on its main diagonal and zeros elsewhere. The notation B≥0 for matrix B indicates that all its elements are nonnegative. We use Sn to refer to the space of n×n symmetric matrices. We use (·)⊤ to refer to the transpose operator for both matrices and vectors. We denote the n×n identity matrix by In, the vector of all ones by e, and the ith unit vector by ei. To avoid overcomplicating notation, we do not specify the dimensions of e and ei but make sure they are always evident from the context. We misuse the notation and denote the real number zero, the vector of all zeroes, and the matrix of all zeroes by zero.

We use Rn to refer to the n-dimensional real-valued Euclidean space, where ‖·‖2 is the Euclidean norm. The standard or unit simplex in Rn, given by {x∈Rn: e⊤x=1, x≥0}, is denoted by Δ.

2. New Reformulations for Quadratic Optimization Problems

This section proposes two reformulations for a quadratic optimization problem (QO). We first show how we can reformulate (QO) as a disjoint biconvex quadratic optimization problem. Using this reformulation, we further provide an equivalent adjustable robust optimization problem. Therefore, we start with the following theorem.

Theorem 1.

Let Q+,−Q−⪰0, and X⊆Rnx be an arbitrary set. Then,

minx∈X x⊤(Q++Q−)x+c⊤x(1)

is equivalent to

minx,y∈Rnx{12x⊤Q+x+12y⊤Q+y+x⊤Q−y+12c⊤x+12c⊤y: x,y∈X}.(Bi-QO)

Proof.

It is clear that

minx∈X x⊤(Q++Q−)x+c⊤x=minx,y∈Rnx{12x⊤Q+x+12y⊤Q+y+x⊤Q−y+12c⊤x+12c⊤y: x=y, x,y∈X}≥minx,y∈Rnx{12x⊤Q+x+12y⊤Q+y+x⊤Q−y+12c⊤x+12c⊤y: x,y∈X},
where the inequality is because the feasible region of the last optimization problem is contained in the feasible region of the middle optimization problem.

To show “≤,” we use the negative semidefiniteness of Q−. For any given x and y in Rnx, because Q−⪯0, we have (x−y)⊤Q−(x−y)≤0. Hence, x⊤Q−x+y⊤Q−y≤2x⊤Q−y. This implies that for any x,y∈Rnx,

x⊤(Q++Q−)x+y⊤(Q++Q−)y≤x⊤Q+x+y⊤Q+y+2x⊤Q−y.

Therefore,

x⊤(Q++Q−)x+y⊤(Q++Q−)y+c⊤x+c⊤y≤x⊤Q+x+y⊤Q+y+2x⊤Q−y+c⊤x+c⊤y.

Now, by taking the minimum over x,y∈X, we have

minx∈X{x⊤(Q++Q−)x+c⊤x}+miny∈X{y⊤(Q++Q−)y+c⊤y}≤minx,y∈X{x⊤Q+x+y⊤Q+y+2x⊤Q−y+c⊤x+c⊤y}.

The fact that

minx∈X{x⊤(Q++Q−)x+c⊤x}=miny∈X{y⊤(Q++Q−)y+c⊤y},
completes the proof. □

It is worth noting that the proof of Theorem 1 does not rely on the specific structure of the feasible set X. If X is convex, then the theorem asserts that any indefinite QO can be reformulated as a disjoint biconvex quadratic optimization problem, where the variables x and y are linked only in the objective function. Furthermore, it can be demonstrated that if x* is an optimal solution for (QO), then the pair (x*,x*) is an optimal solution for (Bi-QO). Conversely, when Q+⪰0 and −Q−≻0, if (x^,y^) is an optimal pair for (Bi-QO), then both x^ and y^ are optimal solutions for (QO), and we have x^=y^. For more details, see Online Supplement A.

From now on, let us restrict the feasible region of (QO) to polytopes, that is, X={x∈Rnx: Ax=b, x≥0} for some A∈Rmx×nx and b∈Rmx, so that X is compact. In the next theorem, we show that we can reformulate the (QO) problem to an adjustable robust optimization problem.

Theorem 2.

Let Q=Q++Q−, where Q∈Rnx×nx, and Q+,−Q−⪰0. Assume that X={x∈Rnx: Ax=b, x≥0} is nonempty compact. Then, the optimal value of (QO) is equal to the optimal value of the following problem:

maxτ∈Rτs.t.∀x∈X, ∃(ux,wx):{12x⊤Q+x+12c⊤x−12ux⊤Q+ux+b⊤wx≥τ,A⊤wx−Q+ux≤Q−x+12c.(ARO-QO)

Proof.

Based on the assumption, we have that (QO) is equivalent to

minx∈Xx⊤(Q++Q−)x+c⊤x,
which is, using Theorem 1, equivalent to
minx,y∈Rnx{12x⊤Q+x+12y⊤Q+y+x⊤Q−y+12c⊤x+12c⊤y: x,y∈X}.(2)

We can write (2) as

minx∈X{12x⊤Q+x+12c⊤x+miny∈X12y⊤Q+y+x⊤Q−y+12c⊤y}.(3)

We consider the inner minimization problem over y for a given x∈X. Because X is nonempty compact, we can apply Dorn duality (Dorn 1960) and rewrite (3) as follows:

minx∈X12x⊤Q+x+12c⊤x+maxux,wx−12ux⊤Q+ux+b⊤wx      s.t.  A⊤wx−Q+ux≤Q−x+12c.(4)

Let x∈X. If the inner maximization is infeasible, its optimal value is −∞, implying that (4) is unbounded. Therefore, in this case, (QO) is unbounded, which contradicts the compactness of X. Therefore, for any x∈X, there is a feasible (ux,wx) for the inner maximization. Thus, using the epigraph reformulation of the objective function, we can rewrite (4) as

maxτ{τ |∀x∈X, ∃(ux,wx):12x⊤Q+x+12c⊤x−12ux⊤Q+ux+b⊤wx≥τ,A⊤wx−Q+ux≤Q−x+12c.},(5)
which completes the proof. □

Problem (ARO-QO) is a quadratic ARO problem with fixed recourse and right-hand side uncertainty. In this problem, τ is the static variable, x∈X is the uncertain parameter, and (ux,wx) is the adjustable variable. The adjustable variables can be seen as functions of x and are known as decision policies (Yanıkoğlu et al. 2019, Khademi et al. 2024).

It is important to note that a concave QO problem, that is, when dealing with a negative semidefinite matrix Q, is NP-hard (Sahni 1974). This complexity primarily arises from the crucial relationship between achieving optimality and enumerating the extreme points within the feasible region (Pardalos and Schnitger 1988). Predominant strategies for addressing concave QO problems typically involve cutting plane methods, branch-and-bound approaches, or iterative computational techniques (Phillips and Rosen 1988, Audet et al. 2005, Chinchuluun et al. 2005, Andrianova et al. 2016). Furthermore, recent studies in this area have focused on establishing bounds from a robust optimization perspective (Selvi et al. 2022), and some have adopted approaches that begin with convex optimization techniques to find starting points and then proceed to gradient descent principles (Ben-Tal and Roos 2022); the application of these techniques has been instrumental in deriving high-quality bounds for the optimal solution. In the subsequent corollary, we present the ARO reformulation for a concave QO problem.

Corollary 1.

Let Q be a negative semidefinite matrix. Assume that X={x∈Rnx: Ax=b, x≥0} is nonempty compact. Then, the optimal value of (QO) is equal to the optimal value of the following problem:

maxτ∈R  τs.t. ∀x∈X, ∃wx:{12c⊤x+b⊤wx≥τ,A⊤wx≤Qx+12c.(6)

Proof.

From Theorem 2 by setting Q+≔0 and Q−≔Q. □

Note that (6) is a linear adjustable robust optimization problem and all techniques in the literature can be used to solve or approximate it.

Remark 1.

In Table 6 of Online Supplement C, we present the equivalent ARO formulations if the polytope X is formulated in another form than canonical.

To approximate (ARO-QO), we can use customary techniques to deal with adjustable variables, such as eliminating the adjustable variables via FME or using decision rules to approximate the adjustable variables. In the next section, we focus on such approximation methods.

3. ARO-Based Approximations

In this section, we recap some of the available customary approaches to approximate our (ARO-QO) problem from the literature and discuss their interpretations concerning (QO).

3.1. Decision Rules

In the (ARO-QO) problem, the adjustable variables ux and wx are, in essence, functions of the uncertain parameter x. One of the popular methods to approximate an ARO problem is by restricting the adjustable variables to belong to a specific class of functions. For example, we can restrict them to be constants, resulting in a static formulation, or to be affine, known as affine decision rule (ADR), which is a good approximation for linear ARO problems (Bertsimas and Bidkhori 2015; Bertsimas et al. 2015, 2010).

Because (ARO-QO) contains a nonlinear convex term ux⊤Q+ux, using ADR to approximate ux results in an intractable approximation. Therefore, we apply a hybrid decision rule to have a tractable approximation. More specifically, we restrict ux to be constant and wx to be affine:

ux≔u and wx≔z+Zx,
where u∈Rnx, z∈Rmx, and Z∈Rmx×nx are static variables. Using this decision rule in (ARO-QO) leads to the following static robust counterpart, which gives a lower bound on the optimal value of (QO):
maxu,z,Z,τ{τ |12x⊤Q+x+12c⊤x−12u⊤Q+u+b⊤(z+Zx)≥τ,∀x∈XA⊤(z+Zx)−Q+u≤Q−x+12c,∀x∈X},(7)
where u, z, and Z are simultaneously optimized together with the static decision variable τ.

In the previous section, we demonstrated that the (QO) problem is equivalent to both the (Bi-QO) and (ARO-QO) problems. In the rest of this section, we explore the relationship between the reformulation-linearization technique (RLT) and the hybrid decision rule.

The RLT was originally proposed by Sherali and Alameddine (1992) and was further developed in Sherali and Tuncbilek (1995). RLT works in two steps: reformulation and linearization. The reformulation step creates additional constraints by multiplying the existing ones. The linearization step then replaces each unique product of variables with a new continuous variable. By applying RLT to approximate the problem with a convex problem, we can find a lower bound on the solution of the original nonconvex minimization problem.

The following theorem demonstrates that (7) is equivalent to applying RLT to the nonconvex part of the objective function in (QO) when representing Q as Q++Q−, and linearizing x⊤Q−x.

Theorem 3.

Let Q=Q++Q− where Q∈Rnx×nx, and Q+,−Q−⪰0. Assume that X={x∈Rnx: Ax=b, x≥0} is nonempty compact. Then, the optimal value of (7) is equal to the optimal value

minγ∈Snxx∈Rnxx⊤Q+x+c⊤x+∑i,j=1nxQij−γijs.t.  Ax=b,Aγ=bx⊤,x≥0, γ≥0.(8)

Proof.

We can rewrite (7) as

maxu,z,Z,τ{τ|minx∈X{12x⊤Q+x+(12c⊤+b⊤Z)x}+b⊤z−12u⊤Q+u≥τ,minx∈X{(−A⊤Z+Q−)ix}+(12c+Q+u−A⊤z)i≥0,i=1,…,nx}.(9)

Because X is a polytope, the inner minimizations are convex optimization problems. Because X is nonempty and compact, strong duality holds (Dorn 1960, Boyd and Vandenberghe 2004). Therefore, (9) is equivalent to

maxu,z,Z,τ τs.t. maxα,β{b⊤β−12α⊤Q+α:  A⊤β−Q+α≤(b⊤Z)⊤+12c}+b⊤z−12u⊤Q+u≥τ, maxθi{b⊤θi: A⊤θi≤((−A⊤Z+Q−)i)⊤}+(12c+Q+u−A⊤z)i≥0, i=1,…,nx.(10)

We can omit the inner maximization operator in the above constraints since the maximizations are bounded. Thus, we have

maxu,z,Z,α,β,θb⊤β−12α⊤Q+α+b⊤z−12u⊤Q+us.t.     A⊤β−Q+α≤(b⊤Z)⊤+12c,b⊤θi+(12c+Q+u−A⊤z)i≥0,i=1,…,nx,A⊤θi≤((−A⊤Z+Q−)i)⊤,i=1,…,nx.(11)

Now, consider the following RLT reformulation of the (Bi-QO) problem:

minγ,x,y12(x⊤Q+x+y⊤Q+y+c⊤x+c⊤y)+∑i,j=1nxQij−γijs.t.  Ax=b,Ay=b,Aγ=by⊤,Aγ⊤=bx⊤,x≥0, y≥0, γ≥0.(12)

We first show that if (x^,y^,γ^) is an optimal solution to (12), and then (x^+y^2,x^+y^2,γ^+γ^⊤2) is also an optimal solution. Because of the optimality of (x^,y^,γ^), it is clear that (y^,x^,γ^⊤) is also an optimal solution. Therefore, the feasibility of (x^+y^2,x^+y^2,γ^+γ^⊤2) is evident. Setting Φ(x,y,γ)≔12(x⊤Q+x+y⊤Q+y+c⊤x+c⊤y)+∑i,j=1nxQij−γij, we know the optimal value of (12) is Φ(x^,y^,γ^)=Φ(y^,x^,γ^⊤). Furthermore, the convexity of x⊤Q+x in x implies that

2Φ(x^+y^2,x^+y^2,γ^+γ^⊤2)≤Φ(x^,y^,γ^)+Φ(y^,x^,γ^⊤)=2Φ(x^,y^,γ^).

Therefore, (x^+y^2,x^+y^2,γ^+γ^⊤2) is an optimal solution to (12).

We have thus shown that there exists an optimal solution to (12) with the structure x=y and γ=γ⊤. We now show that (12) and (8) are equivalent. To demonstrate this, it suffices to show that any optimal solution to (12) corresponds to an optimal solution to (8) with the same objective value. Suppose that (x^,y^,γ^) is optimal for (12). Then (x¯=x^+y^2,x¯=x^+y^2,γ¯=γ^+γ^⊤2) is also optimal for (12). We claim that (x¯,γ¯) is an optimal solution to (8). If the claim is not true, then there exists a feasible solution (x˜,γ˜) such that

x˜⊤Q+x˜+c⊤x˜+∑i,j=1nxQij−γ˜ij<x¯⊤Q+x¯+c⊤x¯+∑i,j=1nxQij−γ¯ij.

This implies that (x˜,x˜,γ˜) is feasible for (12) and achieves a better objective value than (x^,y^,γ^), which is a contradiction.

Now, we show that (11) is the Dorn dual problem of (12) (which is equivalent to (8)). To do this, we first write (12) in the matrix form:

minvec(γ),x,y 12(xyvec(γ))⊤(Q+000Q+0000)(xyvec(γ))+(c2c2vec(Q−))⊤(xyvec(γ))s.t.    (A000A00BCB0D)(xyvec(γ))=(bb00),(xyvec(γ))≥0,(13)
where B≔−(b1Inxb2Inx⋮bmxInx), C≔(A11InxA12Inx⋯A1nnInx⋮⋮⋱⋮Amx1InxAmx2Inx⋯AmxnxInx), and D≔(A1⋯0⋮⋱⋮0⋯A1⋮⋮Amx⋯0⋮⋱⋮0⋯Amx). The dual of (13) is
maxY,W−12Y⊤(Q+000Q+0000)Y+(bb00)⊤Ws.t.−(Q+000Q+0000)Y+(A000A00BCB0D)⊤W≤(c2c2vec(Q−)).(14)

Setting

Y≡(αuY3), W≡(βzvec(θ)vec(Z)),

(14) is the matrix form of (11). Hence, (12) is the dual of the deterministic reformulation of (7). Observe that, because of the property of Dorn duality at the optimal solution, we have Y*=(x*y*vec(γ*)), i.e., x*=α* and y*=u*. □

Theorem 3 establishes that a convex relaxation of the original QO through an RLT is equivalent to approximating its ARO reformulation via hybrid decision rules.

The literature has also considered RLTs to approximate an ARO problem. More specifically, it is shown in Ardestani-Jaafari and Delage (2021) that a linear ARO problem can be reformulated as a bilinear optimization problem using duality techniques. The authors then show that using an RLT to approximate the bilinear optimization reformulation is equivalent to applying ADR to the original problem. In Zhen et al. (2022), the same results are shown for disjoint bilinear problems with convex feasible regions.

Theorem 3 bridges the gap between existing analytical results for approximating ARO problems and those for approximating (QO). This allows us to extend the analytical techniques from one domain to the other. For example, Bertsimas and Bidkhori (2015) provide us with analytical bounds on the quality of the ADR approximation of a linear ARO problem, which can directly be translated to analytical bounds on the quality of (8) to approximate a concave QO problem.

In (QO), we can assume, without loss of generality, that the matrix Q is symmetric; otherwise, we can replace the objective function with x⊤(Q⊤+Q2)x+c⊤x. Now, for a symmetric matrix Q, we know that the eigenvalues are real (O’Nan 1971). Therefore, for an indefinite matrix Q, we can construct the matrices in Theorem 1 in many ways, including the following representations.

Representation 1:

Q+≔Q−(λmin(Q)−ϵ)Inx, and Q−≔(λmin(Q)−ϵ)Inx,

Representation 2:

Q+≔(λmax(Q)+ϵ)Inx, and Q−≔Q−(λmax(Q)+ϵ)Inx,

Representation 3:

Q+≔VΛ+V⊤, and Q−≔VΛ−V⊤,
where V∈Rnx×nx is an orthonormal matrix of eigenvectors of Q, Λ+=Diag(d1+,…,dnx+), Λ−=Diag(d1−,…,dnx−), with di+=max{λi+ϵ,ϵ}, di−=min{λi−ϵ,−ϵ}, and λi being the ith eigenvalue of Q, i=1,…,nx. In all representations, a small positive constant ϵ is chosen to ensure that Q+,−Q−≻0.

The representations above offer a natural method to decompose arbitrary indefinite symmetric matrices by expressing them as the sum of one positive and one negative semidefinite matrix, as also discussed in Bomze (2002a, section 5.2).

Considering Representation 1, we see that Q− is a diagonal matrix, but Q+ has a similar density as Q. Therefore, in (ARO-QO), all entries of ux are linked together via Q+ux. However, in Representation 2, Q+ is a diagonal matrix, implying that the entries of ux are only linked together via ux⊤Q+ux and are not linked in the constraints. In the numerical result section, we will use Representation 2 and Representation 3, showcasing their effectiveness in practical scenarios and their impact on computational efficiency and solution accuracy.

In the rest of this section, we apply the hybrid decision rules to approximate standard quadratic optimization problems.

Example 1.

Let us consider a standard quadratic optimization problem:

minx∈Δ x⊤Q˜x+c⊤x.
We remark that the quadratic function x⊤Q˜x+c⊤x over the unit simplex set can be described as a homogeneous quadratic function x⊤Qx, where Q≔Q˜+12ec⊤+12ce⊤. Hence, without loss of generality, the standard QO problem can be represented as follows:
minx∈Δ x⊤Qx.(StQO)

For an indefinite symmetric matrix Q∈Rnx×nx, Problem (StQO) is NP-hard in general (Bomze and De Klerk 2002). Using Theorem 2, (StQO) is equivalent to

maxτ∈Rτs.t.∀x∈Δ, ∃(ux∈Rnx,wx∈R):{12x⊤Q+x−12ux⊤Q+ux+wx≥τ,−Q+ux+ewx≤Q−x,(ARO-StQO)
where τ is the static variable, x∈Δ is the uncertain parameter, and (ux,wx)∈Rnx×R is the adjustable variable. According to Theorem 3, applying a hybrid decision rule (i.e., ux=u and wx=z+Zx) to (ARO-StQO) is equivalent to approximating (StQO) with the following problem:
minγ∈Snxx∈Rnxx⊤Q+x+∑i,j=1nxQij−γijs.t.   e⊤x=1,e⊤γ=x⊤,x≥0, γ≥0.(15)

Selvi et al. (2023) show that any optimal solution (x*,γ*) of (15) satisfies the sparsity pattern γ*=Diag(x*). Consequently, the number of decision variables in (15) can be reduced. Moreover, they show that adding a semidefinite constraint γ⪰xx⊤ offers no advantage over the relaxed problem (15). Therefore, the lower bound obtained from the hybrid decision rule on (ARO-StQO) is equivalent to

minx∈Rnxx⊤Q+x+diag(Q−)⊤xs.t.  e⊤x=1,x≥0.(16)

3.2. FME

In linear ARO problems with fixed recourse, an adjustable variable may be eliminated by employing FME. This approach effectively handles problems involving a limited number of adjustable variables (Zhen et al. 2018).

Note that for a given x∈X, in (ARO-QO), we have the ability to eliminate the adjustable variable wx∈Rmx. We assume without loss of generality that b≥0. Let k∈{1,…,mx}. To eliminate wxk, the kth component of the vector wx, we first isolate it in the constraints:

{bkwxk≥τ−12x⊤Q+x−12c⊤x+12ux⊤Q+ux−∑j≠kj=1mxbjwxj,Akiwxk≤(Q−x+12c+Q+ux)i−∑j≠kj=1mxAjiwxj,i=1,…,mx.(17)

Because X={x∈Rnx: Ax=b, x≥0} is nonempty, we cannot have bk>0 and Aki≤0 for any i=1,…,mx.

If Aki≠0 and bk>0, then both sides of their respective constraints can be divided by Aki and bk. This yields an equivalent representation of the feasible region, involving the following constraints:

wxk≥1bk(τ−12x⊤Q+x−12c⊤x+12ux⊤Q+ux−∑j≠kj=1mxbjwxj)if bk>0,0≥τ−12x⊤Q+x−12c⊤x+12ux⊤Q+ux−∑j≠kj=1mxbjwxjif bk=0,wxk≥1Aki((Q−x+12c+Q+ux)i−∑j≠kj=1mxAjiwxj)for  i=1,…,mx, where Aki<0,1Akr((Q−x+12c+Q+ux)i−∑j≠kj=1mxAjrwxj)≥wxkfor  r=1,…,mx, where Akr>0,(Q−x+12c+Q+ux)i−∑j≠kj=1mxAjswxj≥0for  s=1,…,mx, where Aks=0.

After the adjustable variable wxk is eliminated, the feasible set becomes

1Akr((Q−x+12c+Q+ux)i−∑j≠kj=1mxAjiwxj)≥1bk(τ−12x⊤Q+x−12c⊤x+12ux⊤Q+ux−∑j≠kj=1mxbjwxj)r=1,…,mx, where bk>0 and Akr>0,0≥τ−12x⊤Q+x−12c⊤x+12ux⊤Q+ux−∑j≠kj=1mxbjwxj         where bk=0,1Akr((Q−x+12c+Q+ux)r−∑j≠kj=1mxAjrwxj)≥1Aki((Q−x+12c+Q+ux)i−∑j≠kj=1mxAjiwxj)i,r=1,…,mx,    where Aki<0 and  Akr>0,(Q−x+12c+Q+ux)s−∑j≠kj=1mxAjswxj≥0      s=1,…,mx, where Ask⊤=0.

By continuing the process of FME, the adjustable variable wx (or some part of it) is eliminated, resulting in a problem with fewer adjustable variables but potentially many more constraints. If the number of constraints in (QO) is limited, then it is computationally efficient to eliminate wx.

In the case of (StQO), applying FME results in a more compact formulation. More explicitly, by applying FME and eliminating the adjustable variable wx, we derive the following equivalent reformulation of (StQO):

maxτ∈Rτs.t.∀x∈Δ, ∃ux: 12x⊤Q+x−12ux⊤Q+ux+(Q−)ix+(Q+)iux≥τ,   i=1,…,nx.(FME-StQO)

The next proposition establishes a connection between approximating the above ARO reformulation and the standard reformulation-linearization technique applied to (StQO).

Proposition 1.

In the (FME-StQO) problem, applying the decision rule ux=x is equivalent to applying standard reformulation-linearization technique relaxation to (StQO), that is,

minγ,x∑i,j=1nxQijγijs.t.  e⊤x=1,e⊤γ=x⊤,x≥0, γ≥0,(RLT-StQO)
with the optimal value of min1≤i,j≤nxQij.

Proof.

Applying the decision rule ux=x results in

maxτ∈R   τ   s.t.   Qix≥τ, ∀x∈Δ, i=1,…,nx,(18)
which is equivalent to
maxτ∈R τs.t. minx∈ΔQix≥τ, i=1,…,nx.(L1-StQO)

The extreme points of the unit simplex Δ are represented by {ej}j=1nx. Because the optimal values are among the extreme point, (L1-StQO) is equivalent to min1≤i,j≤nxQij. Note that the optimal value of (RLT-StQO) is also min1≤i,j≤nxQij, because

∑i,j=1nxQijγij≥∑i,j=1nx(min1≤i,j≤nxQij)γij=(min1≤i,j≤nxQij)∑i,j=1nxγij=min1≤i,j≤nxQij,
where the first inequality holds because each Qij is at least as large as min1≤i,j≤nxQij, the second equality holds because min1≤i,j≤nxQij is a constant factor, and the last equality holds due to the constraints e⊤γ=x⊤ and e⊤x=1, which together enforce that the sum of all entries of γ must equal one. Thus, min1≤i,j≤nxQij is a lower bound on the optimal value of (RLT-StQO). Let Qrs≔min1≤i,j≤nxQij. Clearly, the solution (γ¯,x¯), where
γ¯ij≔{1,if i=r and j=s0,otherwise     and     x¯≔er,
is feasible for (RLT-StQO) with the objective value of Qrs; hence, (RLT-StQO) has the optimal value of min1≤i,j≤nxQij, which is the same applying the decision rule ux=x to (FME-StQO). □

In Proposition 1, we see that applying the special linear decision rule ux=x yields a simple lower bound (LB=min1≤i,j≤nxQij) to the optimal value of the (StQO) problem. This simple lower bound can be tight if and only if the minimum entry of Q is located on the diagonal; otherwise, the approximation is not tight.

4. Solution Method

In the previous section, we explained how to obtain a lower bound using the techniques from ARO literature. This section first provides an algorithm to obtain a feasible solution and construct an upper bound for a general (QO) and then focuses on (StQO).

4.1. General Quadratic Optimization

After solving the approximated problem (7), we use the obtained solution to extract worst-case scenarios from each constraint of the robust counterpart problem (7). Among these scenarios, we select the one that yields the best objective value for the original (QO) problem. After identifying the most favorable scenario, our attention is redirected to the biconvex reformulation of (QO) problem. Given the selected scenario, we employ the mounting claiming (algorithm Algorithm 1) for (Bi-QO) to improve the quality of the solution. This process ultimately leads us to an upper bound for (QO) problem. The mountain climbing procedure was initially introduced by Konno (1976) for bilinear optimization problems, but can easily be extended to biconvex problems, wherein the variable is partitioned into disjoint sets. For further information regarding the convergence theory of the mountain climbing procedure, we refer to Gorski et al. (2007) and Grippo and Sciandrone (2000).

Algorithm 1

(Mountain Climbing Procedure)

Input: Matrix Q and starting point x0.

Initialization: Decompose Q=Q++Q− such that Q+,−Q−⪰0.

Repeat: Execute the following steps:

x(k+1)←arg minx∈Rnx{12x⊤Q+x+x⊤Q−x(k)+12c⊤x: x∈X}.

 Until: No further improvement is possible.

Output: Solution candidate x(end).

By employing the ARO reformulation, biconvex reformulation, and mounting claiming method, we can efficiently explore and improve the solution space, thereby obtaining an upper bound that closely approaches the optimal value. This approach allows us to make significant progress in refining the solution quality while mitigating computational challenges often associated with large-scale optimization problems. Algorithm 2 presents the pseudo-code of the approach discussed above.

Algorithm 2

(ARO-Based Algorithm to Obtain an Upper Bound for QO)

Input: Matrix Q, vector c, matrix A, and vector b.

Initialization: Decompose Q=Q++Q− such that Q+,−Q−⪰0.

(Step 1) Lower Bound: Compute the lower bound for the approximated problem based on the ARO formulation of the QO and hybrid decision rule (see Section 3).

(Step 2) Generation of Worst-Case Scenarios: Generate a finite set of worst-case scenarios by substituting the optimal decision rule into (7).

(Step 3) Set Initial Point: Select from these scenarios the one that yields the best objective value for the original QO problem. Denote this point by x(0).

(Step 4) Improve the Initial Solution: Execute the mountain climbing algorithm starting with the initial solution x(0):

x(k+1)←arg minx∈Rnx{12x⊤Q+x+x⊤Q−x(k)+12c⊤x: x∈X}.

(Step 5) Termination: Continue (Step 4) until no further improvement is observed.

Output: Final solution candidate x*≔x(end), and the corresponding upper bound value UB≔(x*)⊤Qx*+c⊤x*.

4.2. Standard Quadratic Optimization

Based on our findings in Section 3, we tackle the (StQO) problem using Algorithm 2, generating a finite set of worst-case scenarios in Step 2 based on two lower-bound approximations for (StQO).

4.2.1. Scenario Based on (L1-StQO).

To select scenarios, we can use the following optimization problems:

x¯i∈arg minx∈Δ{Qix},  i=1,…,nx.(19)

However, we do not need to solve linear optimization problems in (19) to find {x¯i}i=1nx because we only need to consider the extreme points of the unit simplex set, that is, {ei}i=1nx. These points provide the natural upper bound (i.e., ei⊤Qei=Qii), which exists in the literature (Gondzio and Yıldırım 2021, lemma 2.1).

To collect additional worst-case scenarios beyond the extreme points of the unit simplex, we also use (FME-StQO), where applying a constant decision rule on ux (i.e., ux=u) results in

maxτ∈R,u∈Rnx τ      s.t.  12x⊤Q+x−12u⊤Q+u+(Q−)ix+(Q+)iu≥τ,   ∀x∈Δ,   i=1,…,nx.(L2-StQO)

4.2.2. Scenario Based on (L2-StQO).

Using this approximation, we can use the following problem to generate scenarios:

x^i∈arg minx∈Δ{12x⊤Q+x+Qi−x},   i=1,…,nx.(20)

We denote by x(0) the scenario with the lowest objective value from all scenarios, that is,

x(0)∈arg minx{x⊤Qx: x∈{x^i}i=1nx∪{ei}i=1nx}.(21)

After choosing x(0) from either of the approaches above, we move to Step 4 of Algorithm 2. In this step by using this initial point, we can improve this initial solution, to get the candidate solution, with its corresponding objective value serving as an upper bound.

5. Numerical Experiments

In this section, we conduct a comprehensive numerical experiment to evaluate the efficacy of Algorithm 2, which we call the ARO-QO algorithm. The efficiency of a particular bound on the optimal value of a mathematical optimization problem is influenced by two key aspects: the precision of the generated bound and the required computational time.

We implement the numerical experiments using MATLAB 2022a. The computations are executed on a laptop equipped with an Intel(R) Core(TM) i5-3210M CPU at 2.50 GHz and 8 GB of RAM. We use YALMIP to pass optimization problems to suitable solvers (Löfberg 2004).

We emphasize that the computational times reported in our experiments exclude the time required by YALMIP to build the model and pass it to solvers, and we merely consider the time consumed by the solvers themselves. In what follows, we present the numerical experiments, specifically focusing on concave quadratic minimization, standard quadratic optimization, and general indefinite quadratic optimization. All the instances and the code are available in the repository Khademi and Marandi (2025).

We use off-the-shelf global solvers to solve the QO problems, namely Gurobi (Gurobi Optimization 2023, version 10.0) and CPLEX (IBM 2019, version 12.9). We specifically use CPLEX version 12.9, as Zhen et al. (2022) reported a bug in the solver of newer versions for solving nonconvex QO problems. It is crucial to highlight that these solvers aim to achieve global solutions. Moreover, MOSEK (MOSEK ApS 2023, version 10.1.15) is used to solve second-order cone optimization problems.

5.1. Concave Quadratic Minimization

Let us consider a concave quadratic minimization over a polyhedron

minx≥0x⊤Qx+c⊤xs.t.Ax≥b,(22)
where Q∈Rnx×nx, and −Q⪰0, c∈Rnx, A∈Rmx×nx, and b∈Rmx are given. From Corollary 1 and Table 6 in Online Supplement C, we have the following linear ARO reformulation of (22):
maxτ∈Rτs.t.∀x∈X, ∃wx:{12c⊤x+b⊤wx≥τ,A⊤wx≤Qx+12c,wx≥0,(23)
where X={x∈Rnx: Ax≥b, x≥0}. To obtain a lower bound, we consider the following decision rule:
wx≔(z+Zxw),
where for a given r∈{1,2,…,mx}, z∈Rr, Z∈Rr×nx, and w∈R(mx−r) are static variables. It is important to note that for r=mx, we obtain a full affine decision rule, whereas for r=0, we have a static decision rule. For other values, we have a partial affine decision rule. Each decision rule type has its own advantages and disadvantages, which we will address later in this section.

In Selvi et al. (2022), the authors propose an approximation solution approach for solving a concave minimization problem via ARO by providing upper and lower bounds, where the lower bound is formulated as a second-order cone optimization problem. Furthermore, the solution method proposed by Ben-Tal and Roos (2022) finds near-optimal solutions to concave minimization problems. This method consists of two main phases. In the initial phase, the method employs several approaches to approximate the original problem with a tractable convex optimization problem. Subsequently, in the second phase, the method employs conditional gradient descent and iterates through various starting points generated in the initial phase, thereby enhancing the quality of the final solution. It is worth mentioning that this method only provides an upper bound on the problem. In this section, we compare the quality of the solution obtained by the ARO-QO algorithm with Gurobi, CPLEX, Selvi et al. (2022), and Ben-Tal and Roos (2022). In all of our numerical experiments, we set a maximum time limit of 3,000 seconds.

We analyze the performance of the upper and lower bound in terms of the optimality gap, which is measured as follows:

OGap(%)=(UB−LB|UB|+10−4)×100,
where LB is the lower bound and UB is the upper bound for a given instance. Adding the small constant 10−4 in the denominator ensures the prevention of division by zero. Additionally, we analyze the performance of the upper bounds in terms of the solution gap, measured as
SGap(%)=(UB−UB(best)|UB|+10−4)×100,
where UB is the objective value of the solution obtained by the specific approach, and UB(best) is the minimum of these bounds over all approaches. Therefore, SGap shows how far a solution from an approach is compared with the best-found solution.

5.1.1. Problem Instances.

First, we consider the seven test instances from section 4.3 of Selvi et al. (2022). We undertake a detailed comparison of three versions of the ARO-QO algorithm (static, partial, and fully affine), Selvi et al. (2022), Ben-Tal and Roos (2022), and global solvers Gurobi and CPLEX. In the lower bound approximation of the ARO-QO algorithm, applying fully static, partially affine (restricting the first r=[mx7]+1 of wx to be affine and the remaining mx−r to be constant), and fully affine decision rules has distinct effects on the optimality gaps.

Table 1 demonstrates a clear correlation between the type of decision rules and the tightness of optimality gaps within our proposed ARO-QO algorithm. The fully affine ARO-QO algorithm consistently achieves the smallest optimality gaps among its variants, providing the tightest bounds for problems it can solve within the time limit. However, this precision comes at the cost of significantly longer solver times, particularly for larger problems. For instance, Problem 5 required 900.48 seconds, whereas Problems 6 and 7 exceeded the 3,000-second time limit. In contrast, the static and partial ARO-QO algorithms offer a balance between solution quality and speed, achieving competitive optimality gaps within reasonable time frames, especially for larger problems like Problem 7. Global solvers Gurobi and CPLEX demonstrate acceptable performance on smaller instances (Problems 1–6), consistently achieving optimality. However, they struggle with the largest problem (Problem 7), where both solvers reach time limits.

Table

Table 1. Solution and Optimality Gaps for Concave Quadratic Minimization Instances from Selvi et al. (2022)

Table 1. Solution and Optimality Gaps for Concave Quadratic Minimization Instances from Selvi et al. (2022)

Problem (mx,nx)Static ARO-QOPartial affine ARO-QOFull affine ARO-QO
SGapOGapTimeSGapOGapTimeSGapOGapTime
#1 (10, 20)0.0030.380.050.0027.970.150.000.021.05
#2 (10, 20)0.009.130.050.008.940.150.000.011.06
#3 (15, 10)0.000.420.030.000.290.060.000.000.12
#4 (62, 50)0.000.120.130.000.090.480.000.0011.46
#5 (130, 100)0.000.080.320.000.074.810.000.00900.48
#6 (240, 200)0.000.020.950.000.0244.83––3,000*
#7 (280, 240)0.000.041.360.000.04104.90––3,000*
Selvi et al. (2022)Ben-Tal and Roos (2022)
Problem (mx,nx)SGapOGapTimeSGapTime
#1 (10, 20)0.0077.850.170.006.78
#2 (10, 20)0.0034.730.150.007.67
#3 (15, 10)0.001.680.150.008.18
#4 (62, 50)0.001.101.320.006.95
#5 (130, 100)0.002.158.270.007.77
#6 (240, 200)0.001.5259.600.0011.27
#7 (280, 240)0.005.7180.900.0013.06
GurobiCPLEX
Problem (mx,nx)SGapOGapTimeSGapOGapTime
#1 (10, 20)0.000.000.110.000.000.12
#2 (10, 20)0.000.000.120.000.000.11
#3 (15, 10)0.000.000.030.000.010.06
#4 (62, 50)0.000.000.560.000.001.56
#5 (130, 100)0.000.0012.030.000.0043.64
#6 (240, 200)0.000.00528.990.000.001,165.38
#7 (280, 240)12.4815.223,000*0.0016.513,000*


Notes. The asterisk ‘*’ indicates that the method reached the time limit. OGap, optimality gap, which measures the relative difference between the upper and lower bounds of the solution; SGap, solution gap, which measures the relative difference between a given solution’s upper bound and the best upper bound found across all methods; –, not possible to determine the bound within the 3,000-second time limit.

Although the method of Ben-Tal and Roos (2022) offers a notable balance between solution quality and speed across all problem sizes, by consistently achieving reasonable solution gaps with competitive computation times, the fully static version of our algorithm outperforms their method in all instances. The method of Selvi et al. (2022), although providing relatively quick solutions, typically leads to larger optimality gaps compared with the ARO-QO algorithm due to its less tight lower bounds (see Table 10 in Online Supplement D for more details). Moreover, the solver times for the Selvi et al. (2022) method are generally longer than those of the static ARO-QO algorithm. The results of our analysis indicate that the static ARO-QO algorithm demonstrates superior performance compared with the method proposed by Selvi et al. (2022) when considering both optimality gap and computational efficiency.

Even though the static ARO-QO algorithm yields the highest optimality gap among other decision rules, it stands out for its minimal computation time required to derive both lower and upper bounds. In the static ARO-QO algorithm, based on the structure of Problem (23), the upper bound can be calculated by directly identifying worst-case scenarios and then improving the best one using the mountain climbing procedure to reach a candidate solution. Furthermore, we incorporate the worst-case scenario corresponding to each constraint in (23), resulting in a linear optimization problem that yields the lower bound. Remarkably, in all seven instances, the calculated upper bound is obtained computationally efficiently with good solution quality. Compared with alternative approaches—such as partial or full affine ARO-QO algorithms, or using the methods of Selvi et al. (2022) and Ben-Tal and Roos (2022)—the static ARO-QO algorithm demonstrates a faster computation process in reaching a candidate solution.

After considering the seven test instances of Selvi et al. (2022), we randomly generate large-size instances. For a meaningful comparison of the mentioned approaches, we evaluate the quality of the bounds on the objective value of Problem (22) using 15 groups of random instances, with the dimension nx taking value in {50,100,…,600,700} with the number of constraints mx=nx+50 and mx=nx+100. Each group contains five instances of the same size, which are generated similarly to those created in Selvi et al. (2022).

Table 2 presents a comparison of various methods for 15 groups of increasing size. For each group, the table lists the mean optimality gap, solution gap, and solver time, with standard deviations shown in brackets (see Table 7 in Online Supplement D for more details). Boldface numbers highlight the best solution gap, and underlined numbers highlight the best optimality gap in each group.

Table

Table 2. Statistic of Solution and Optimality Gaps and Solver Times for Randomly Generated Concave Minimization Instances

Table 2. Statistic of Solution and Optimality Gaps and Solver Times for Randomly Generated Concave Minimization Instances

Group (mx,nx)Static ARO-QOSelvi et al. (2022)
OGapSGapTimeOGapSGapTime
#1 (100, 50)1.54 [0.35]0.03 [0.07]0.20 [0.01]13.32 [0.94]0.00 [0.00]2.20 [0.28]
#2 (150, 100)1.49 [0.35]0.03 [0.04]0.49 [0.01]13.81 [0.88]0.00 [0.00]9.00 [0.40]
#3 (200, 100)1.71 [0.36]0.05 [0.08]0.72 [0.03]16.37 [0.97]0.01 [0.01]17.83 [1.46]
#4 (250, 200)1.40 [0.37]0.01 [0.02]1.43 [0.11]14.71 [2.03]0.00 [0.01]51.25 [4.76]
#5 (300, 200)1.33 [0.13]0.00 [0.00]2.60 [0.11]17.02 [1.03]0.01 [0.01]101.50 [22.87]
#6 (350, 300)1.62 [0.19]0.01 [0.01]2.89 [0.09]16.38 [1.18]0.02 [0.03]154.01 [10.49]
#7 (400, 300)1.53 [0.28]0.00 [0.00]5.40 [0.19]18.83 [2.21]0.73 [1.62]256.42 [30.29]
#8 (450, 400)1.70 [0.25]0.00 [0.01]4.81 [0.15]16.21 [1.83]0.00 [0.00]295.57 [12.37]
#9 (500, 400)1.89 [0.20]0.00 [0.00]9.29 [0.37]19.38 [0.77]0.02 [0.02]556.61 [19.42]
#10 (550, 500)1.79 [0.08]0.00 [0.00]7.24 [0.17]16.92 [0.56]0.01 [0.01]256.74 [15.37]
#11 (600, 500)1.64 [0.19]0.00 [0.00]17.66 [0.47]19.24 [0.66]0.01 [0.01]504.47 [15.83]
#12 (650, 600)1.57 [0.12]0.00 [0.00]13.09 [0.51]17.17 [0.89]0.01 [0.01]424.63 [43.45]
#13 (700, 600)1.48 [0.29]0.00 [0.00]23.83 [0.57]18.89 [1.50]0.02 [0.01]821.51 [75.41]
#14 (750, 700)1.79 [0.39]0.10 [0.23]16.92 [0.53]17.33 [1.08]0.02 [0.02]503.12 [36.98]
#15 (800, 700)1.48 [0.21]0.00 [0.00]31.60 [1.23]19.21 [1.47]0.01 [0.02]1,164.43 [515.86]
Ben-Tal and Roos (2022)Gurobi
Group (mx,nx)SGapTimeOGapSGapTime
#1 (100, 50)0.00 [0.00]9.47 [3.81]0.01 [0.00]0.00 [0.00]66.53 [44.43]
#2 (150, 100)0.00 [0.00]10.05 [0.73]0.01 [0.00]0.00 [0.00]776.08 [407.71]
#3 (200, 100)0.00 [0.00]12.50 [0.55]0.02 [0.02]0.00 [0.00]1,602.76 [1,035.26]
#4 (250, 200)0.00 [0.00]11.31 [0.12]10.69 [10.33]0.15 [0.33]3,000*
#5 (300, 200)0.00 [0.00]12.96 [0.18]25.93 [3.34]0.00 [0.00]3,000*
#6 (350, 300)0.05 [0.12]16.31 [0.19]23.85 [3.49]0.12 [0.12]3,000*
#7 (400, 300)0.00 [0.00]19.06 [0.29]37.02 [2.57]0.06 [0.11]3,000*
#8 (450, 400)0.00 [0.00]22.28 [0.23]118.90 [88.99]23.26 [22.36]3,000*
#9 (500, 400)0.01 [0.02]26.50 [0.70]171.95 [103.12]8.76 [18.96]3,000*
#10 (550, 500)0.00 [0.00]29.42 [0.65]2,521.58 [5,213.52]71.26 [46.24]3,000*
#11 (600, 500)0.00 [0.00]34.92 [1.26]5,420.98 [4,697.11]75.31 [35.19]3,000*
#12 (650, 600)0.00 [0.00]37.81 [1.27]8,616.82 [5,403.16]158.20 [22.93]3,000*
#13 (700, 600)0.01 [0.02]45.35 [1.73]10,233.75 [1,598.93]91.68 [3.34]3,000*
#14 (750, 700)0.00 [0.00]47.67 [1.18]––3,000*
#15 (800, 700)0.00 [0.00]56.33 [0.86]––3,000*
CPLEX
Group (mx,nx)OGapSGapTime
#1 (100, 50)0.01 [0.00]0.00 [0.00]16.93 [2.14]
#2 (150, 100)0.02 [0.01]0.00 [0.00]382.64 [181.74]
#3 (200, 100)0.12 [0.15]0.00 [0.00]1,285.16 [1,256.08]
#4 (250, 200)0.22 [0.35]0.15 [0.33]2,927.72 [161.62]
#5 (300, 200)0.43 [6.26]0.00 [0.00]3,000*
#6 (350, 300)1,365.22 [1,636.18]0.12 [0.12]3,000*
#7 (400, 300)4,104.90 [236.04]0.06 [0.11]3,000*
#8 (450, 400)––3,000*
#9 (500, 400)––3,000*
#10 (550, 500)––3,000*
#11 (600, 500)––3,000*
#12 (650, 600)––3,000*
#13 (700, 600)––3,000*
#14 (750, 700)––3,000*
#15 (800, 700)––3,000*


Notes. This table categorizes problems into groups in the first column based on dimensions. The subsequent columns display “mean [standard deviation]” values of each subgroup’s solution and optimality gaps and solver time. –, not possible to determine upper bounds for all instances of the corresponding group within the maximum time limit. Bold numbers indicate the best solution gap, whereas underlined numbers show the best optimality gap per group.

Our proposed (static) ARO-QO algorithm demonstrates remarkable consistency, maintaining strong performance across all problem dimensions. It achieves the best optimality gaps for larger problems (Groups 6–15), with the average optimality gap being less than 2% for all groups, and solves all instances within the time limit with very low solution gaps. Notably, the ARO-QO algorithm exhibits the lowest computation time compared with other methods in each group, underscoring its efficiency in balancing time and gap management across these instances. The method by Selvi et al. (2022) displays more consistent optimality gaps across all problem groups, despite being significantly higher than those of Gurobi and CPLEX for the smaller instances. The method of Ben-Tal and Roos (2022) consistently achieves the best average solution gap, which is always below 0.05%, with a maximum standard deviation of 0.12% across all problem sizes, although it cannot provide optimality gaps.

Global solvers Gurobi and CPLEX perform exceptionally well for smaller problems (Groups 1–3), with Gurobi achieving very low optimality gaps. However, they begin to struggle with larger problems from Group 4 onward. Gurobi and CPLEX have acceptable solution gaps up to Group 7, but Gurobi could not find feasible solutions for instances in Groups 14 and 15, whereas CPLEX failed to find feasible solutions for instances in Groups 8–15, all within the given 3,000-second time limit. This highlights the challenges these solvers face with large-scale instances.

5.2. Standard Quadratic Optimization

Let us consider a standard quadratic optimization problem

minx∈Δ x⊤Qx,(StQO)
where Q∈Rnx×nx is an indefinite symmetric matrix.

In Proposition 1, we see that applying the special linear decision rule ux=x after eliminating an adjustable variable yields a lower bound approximation problem (RLT-StQO) to the optimal value of the (StQO) problem. Adding the additional semidefinite constraint γ⪰xx⊤ in (RLT-StQO) results in a progressively tighter bound. However, this comes at the expense of significant computational demands (Selvi et al. 2023). For large-sized problems, this bound frequently encounters “out-of-memory” errors during the solving process, making it generally inapplicable.

Gondzio and Yıldırım (2021) propose an exact mixed-integer linear optimization (MILO) reformulation for (StQO):

minx,y,z,ααs.t.  e⊤x=1,Qx≤eα+z,0≤x≤y,0≤zi≤(1−yi)Mi, i=1,…,nx,y∈{0,1}nx,(MILO-StQO)
where nonnegative parameter M∈Rnx depends on a lower bound of the optimal value of (StQO), ensuring that the optimal value of (MILO-StQO) is equivalent to the optimal value of (StQO).

We will explore how to enhance the solution quality of the (MILO-StQO) formulation by integrating the ARO-QO algorithm.

5.2.1. Problem Instances.

It is of paramount importance to note that, with a high probability, global solutions of randomly generated (StQO) instances are located either at vertices or edges of the standard simplex (Bomze et al. 2018). In order to make a fair comparison, we do not generate naive random instances in our study because our upper bound methodology would be optimal in these cases. Instead, we concentrate on using instances from well-known data sets or employing their patterns to generate new instances, as outlined by Liuzzi et al. (2019).

5.2.2. Detailed Results.

We consider 15 groups each of which contains five instances with the dimension nx taking values in {500,600,700,800,900}. These test problems were generated using the pattern described in Liuzzi et al. (2019) and Scozzari and Tardella (2008). Another important factor affecting the performance of different solution methods is the density of matrix Q. We examine three density values for each dimension: 50%, 75%, and 90%. For further details, we refer the reader to Scozzari and Tardella (2008).

In the initial comparison, we evaluate the quality of the ARO-based upper bound approximation against CPLEX local search. Setting cplex.optimalitytarget option to 2 allows CPLEX to solve indefinite quadratic optimization problems locally. This configuration guarantees solutions that satisfy first-order optimality conditions but not necessarily global optimality. Analysis of these bounds, obtained through local solution methods, provides insights into the problem’s computational complexity.

Table 3 provides statistics on the solution gap and the time it takes for ARO-QO and CPLEX to obtain a solution. As one can see, the ARO-QO algorithm demonstrates frequently better performance compared with CPLEX local search in terms of upper bound quality and computational efficiency. More specifically, the ARO-QO algorithm outperforms CPLEX local search in 46 of 75 instances, whereas CPLEX local search produces better upper bounds in only 28 instances, with 1 instance resulting in equal performance (see Table 8 in Online Supplement D). This comparison highlights the ARO-QO algorithm’s consistent ability to generate good upper bounds for most test instances. Overall, across all instances, the average solution gaps are 4.15% and 5.75% (with the maximum value of 14.53% and 19.73%), respectively, for ARO-QO and CPLEX. From a solution time perspective, the ARO-QO algorithm also exhibits better performance. It consistently solves instances more quickly. In Table 3, we see that ARO-QO Algorithm outperforms CPLEX local in solution quality for 11 of 15 problem groups, particularly excelling in larger instances.

Table

Table 3. Comparison of Solution Gaps and Solver Times for Standard Quadratic Optimization Instances Between ARO-QO Algorithm and CPLEX Local Search

Table 3. Comparison of Solution Gaps and Solver Times for Standard Quadratic Optimization Instances Between ARO-QO Algorithm and CPLEX Local Search

Group (dimension, density)ARO-QO algorithmCPLEX local search
SGapTimeSGapTime
#1 (nx=500,d=0.50)5.91 [3.14]7.38 [0.76]13.69 [4.94]6.22 [1.17]
#2 (nx=500,d=0.75)5.07 [2.76]6.30 [1.08]2.88 [3.81]4.94 [0.79]
#3 (nx=500,d=0.90)2.96 [2.06]5.87 [0.90]2.87 [1.36]4.91 [1.00]
#4 (nx=600,d=0.50)4.57 [5.09]13.12 [4.34]5.85 [3.76]10.56 [2.54]
#5 (nx=600,d=0.75)3.19 [2.58]8.79 [1.96]3.69 [1.96]11.30 [2.63]
#6 (nx=600,d=0.90)5.02 [2.45]10.72 [3.83]3.66 [1.29]9.73 [2.11]
#7 (nx=700,d=0.50)6.05 [2.89]15.00 [3.75]7.26 [3.16]14.10 [1.28]
#8 (nx=700,d=0.75)4.92 [1.48]10.61 [1.13]5.42 [1.71]13.25 [0.82]
#9 (nx=700,d=0.90)2.67 [1.58]10.55 [3.19]2.56 [1.50]13.82 [0.94]
#10 (nx=800,d=0.50)3.65 [2.03]25.05 [9.89]9.36 [1.94]23.81 [4.52]
#11 (nx=800,d=0.75)2.88 [2.15]12.51 [3.96]5.26 [4.03]22.67 [5.01]
#12 (nx=800,d=0.90)1.59 [1.30]12.10 [1.91]2.76 [2.19]27.28 [7.75]
#13 (nx=900,d=0.50)9.34 [3.62]20.31 [0.95]12.31 [5.90]34.32 [5.61]
#14 (nx=900,d=0.75)2.79 [1.73]14.23 [2.01]3.99 [2.06]33.61 [5.05]
#15 (nx=900,d=0.90)1.73 [2.16]13.91 [1.04]4.68 [2.01]35.05 [9.31]


Notes. This table categorizes problems into groups in the first column. The subsequent columns display “mean [standard deviation]” values of each subgroup’s solution gap and solver time. Bold numbers indicate the best solution gap of these two approaches per group.

Given that our approach obtained a good solution, we use it to improve the performance of (MILO-StQO) reformulation. Specifically, because the objective function of (MILO-StQO) is linear, we can restrict the objective function to only get values between the valid lower and upper bounds, that is, LB≤α≤UB, potentially accelerating convergence and improving solution quality by guiding the solver toward more promising areas of the search space. It is worth mentioning that Gondzio and Yıldırım (2021) used UB≔min1≤i≤nxQii as a natural upper bound, which corresponds to the best objective value achievable for (StQO) when restricted to the vertices of the unit simplex. For the lower bound, they used a tight SDO-based bound. However, in our instances, because of out-of-memory errors, this type of bound is not applicable, so we use (L1-StQO) as a valid lower bound. We remark that there exist other lower bounds in the literature (Bomze et al. 2008, Liuzzi et al. 2019).

Based on the upper bound UB obtained from the ARO-QO algorithm, we first generate a feasible solution (x¯,y¯,z¯,α¯) for (MILO-StQO) such that α¯≤UB. To do so, we use CPLEX, because it has fast heuristic algorithms to find a feasible solution for MILOs. We then use this solution as a warm starting point for (MILO-StQO) and add the extra objective cut LB≤α.

In this part of the numerical results, we compare the following approaches to solve (StQO): the original (MILO-StQO); its variant with the additional LB and UB cuts (MILO-L-U), where UB is the natural upper bound (as in Gondzio and Yıldırım (2021)); and its variant with LB cut and ARO-based warm start (ARO-QO-MILO). Additionally, we compare these with global solvers Gurobi and CPLEX. All (MILO-StQO) versions are solved using Gurobi as the MILO solver.

Table 4 shows the statistics of the results. In this table, the first column represents the group of instances, including the number of variables (nx) and the density (d). The subsequent columns are organized into five different solution methods. For each method, three performance metrics are reported: optimality gap, solution gap, and solver time in seconds. Each cell contains the mean value and standard deviation in brackets. Bold numbers indicate the best (lowest) solution gap, whereas underlined numbers show the best (lowest) optimality gap for each group. An asterisk in the time column indicates that the method is terminated due to the time restriction.

Table

Table 4. Statistic of Solution and Optimality Gaps and Solver Times for Standard Quadratic Optimization Instances

Table 4. Statistic of Solution and Optimality Gaps and Solver Times for Standard Quadratic Optimization Instances

Group (nx,d)MILOMILO-L-U
OGapSGapTimeOGapSGapTime
#1 (500, 0.50)0.00 [0.00]0.00 [0.00]1,929.83 [87.33]0.00 [0.00]0.00 [0.00]826.85 [133.51]
#2 (500, 0.75)2.55 [2.33]0.00 [0.00]2,930.34 [102.62]0.00 [0.00]0.00 [0.00]2,124.75 [296.42]
#3 (500, 0.90)7.32 [2.78]0.00 [0.00]3,000*4.85 [2.91]0.00 [0.00]2,960.18 [89.04]
#4 (600, 0.50)176.76 [5.92]0.25 [0.34]3,000*0.00 [0.00]0.00 [0.00]2,160.33 [177.22]
#5 (600, 0.75)55.02 [80.93]0.55 [0.58]3,000*11.17 [0.92]0.18 [0.37]3,000*
#6 (600, 0.90)15.91 [1.43]0.04 [0.08]3,000*12.55 [1.32]0.36 [0.62]3,000*
#7 (700, 0.50)182.14 [3.99]0.91 [1.18]3,000*8.84 [3.04]0.03 [0.06]3,000*
#8 (700, 0.75)206.24 [4.23]1.36 [1.58]3,000*16.35 [1.99]0.60 [0.56]3,000*
#9 (700, 0.90)213.46 [2.59]1.14 [1.12]3,000*16.56 [1.16]0.00 [0.00]3,000*
#10 (800, 0.50)185.63 [2.43]0.29 [0.46]3,000*20.33 [2.14]0.30 [0.67]3,000*
#11 (800, 0.75)210.48 [2.12]0.86 [0.77]3,000*61.74 [88.49]41.09 [89.05]3,000*
#12 (800, 0.90)220.40 [3.61]1.07 [0.99]3,000*19.61 [0.77]0.30 [0.60]3,000*
#13 (900, 0.50)185.11 [2.21]0.21 [0.44]3,000*25.17 [0.70]0.31 [0.41]3,000*
#14 (900, 0.75)212.18 [3.16]1.34 [1.33]3,000*23.67 [1.11]0.51 [0.66]3,000*
#15 (900, 0.90)225.00 [1.14]2.15 [1.09]3,000*21.93 [1.51]0.47 [0.71]3,000*
ARO-QO-MILOGurobi
Group (nx,d)OGapSGapTimeOGapSGapTime
#1 (500, 0.50)0.00 [0.00]0.00 [0.00]887.20 [129.78]1,972.38 [1,850.29]7.31 [3.44]3,000*
#2 (500, 0.75)0.00 [0.00]0.00 [0.00]2,191.32 [263.73]26.98 [4.43]2.77 [2.21]3,000*
#3 (500, 0.90)4.93 [2.96]0.00 [0.00]2,872.41 [285.29]26.23 [4.02]3.81 [2.78]3,000*
#4 (600, 0.50)0.00 [0.00]0.00 [0.00]2,241.34 [181.76]2,687.31 [1,691.32]8.69 [2.58]3,000*
#5 (600, 0.75)12.74 [4.64]0.00 [0.00]3,000*1,955.29 [2,667.52]4.54 [2.33]3,000*
#6 (600, 0.90)12.02 [1.14]0.03 [0.07]3,000*27.81 [5.44]4.42 [3.08]3,000*
#7 (700, 0.50)9.59 [1.95]0.00 [0.00]3,000*9,426.52 [955.51]5.06 [4.97]3,000*
#8 (700, 0.75)17.21 [1.49]1.18 [1.57]3,000*15,809.10 [4,620.84]2.10 [1.95]3,000*
#9 (700, 0.90)17.93 [3.01]0.28 [0.43]3,000*15,804.48 [1,280.84]6.25 [2.32]3,000*
#10 (800, 0.50)20.79 [1.69]0.17 [0.15]3,000*17,214.45 [718.18]7.21 [3.56]3,000*
#11 (800, 0.75)20.51 [0.90]0.07 [0.13]3,000*24,206.49 [3,539.76]5.06 [2.85]3,000*
#12 (800, 0.90)22.49 [5.68]0.12 [0.28]3,000*26,275.01 [4,764.03]4.33 [1.16]3,000*
#13 (900, 0.50)24.48 [1.43]0.03 [0.07]3,000*23,731.50 [1,504.65]8.58 [4.06]3,000*
#14 (900, 0.75)23.54 [0.95]0.00 [0.00]3,000*33,231.50 [1,583.20]3.40 [2.49]3,000*
#15 (900, 0.90)22.68 [0.64]0.61 [1.36]3,000*39,919.59 [571.37]3.18 [0.99]3,000*
CPLEX
Group (nx,d)OGapSGapTime
#1 (500, 0.50)61,772,219.07 [54,491,734.55]957.04 [766.36]3,000*
#2 (500, 0.75)92,672,786.53 [82,304,244.51]987.47 [781.11]3,000*
#3 (500, 0.90)111,064,986.98 [98,903,826.58]1,010.48 [820.30]3,000*
#4 (600, 0.50)86,173,185.08 [60,661,256.69]929.23 [581.79]3,000*
#5 (600, 0.75)129,433,672.53 [91,250,582.32]967.01 [617.40]3,000*
#6 (600, 0.90)155,111,853.68 [109,405,777.34]982.44 [622.62]3,000*
#7 (700, 0.50)374,534,570.36 [600,759,655.77]2,827.11 [4,394.98]3,000*
#8 (700, 0.75)561,860,313.36 [900,673,927.18]2,893.43 [4,487.49]3,000*
#9 (700, 0.90)673,291,316.71 [1,078,887,498.54]2,905.61 [4,492.97]3,000*
#10 (800, 0.50)213,944,685.06 [256,201,132.95]1,264.89 [1,390.58]3,000*
#11 (800, 0.75)321,304,714.38 [385,347,544.93]1,313.44 [1,458.89]3,000*
#12 (800, 0.90)385,112,553.77 [461,880,487.68]1,339.63 [1,495.70]3,000*
#13 (900, 0.50)187,345,502.54 [68,002,456.84]913.82 [300.76]3,000*
#14 (900, 0.75)281,072,681.59 [102,072,591.74]939.96 [307.88]3,000*
#15 (900, 0.90)336,989,667.40 [122,404,416.52]956.45 [307.51]3,000*


Notes. This table categorizes problems into groups in the first column based on dimension (nx) and density (d). The subsequent columns display “mean [standard deviation]” values of each subgroup’s solution and optimality gaps and solver time. Bold numbers indicate the best solution gap, while underlined numbers show the best optimality gap per group.

For small instances (nx=500), all MILO variants perform well, often with zero gaps. MILO-L-U and ARO-QO-MILO are typically faster. As problem size increases, all methods reach the time limit, and performance differences become clearer. ARO-QO-MILO significantly improves solution quality, consistently achieving the best optimality and solution gaps, even for larger problems. Detailed results are in Table 8 of Online Supplement D.

The ARO-QO-MILO’s benefits are evident in its consistent outperformance of MILO-L-U, especially regarding solution quality. In contrast, both Gurobi and CPLEX struggle with larger instances, consistently producing higher optimality and solution gaps compared with the MILO variants. CPLEX, in particular, shows extremely large optimality gaps for all problem sizes. These results suggest that ARO-QO-MILO is promising for enhancing the performance of MILO reformulations for quadratic optimization problems. This method is particularly valuable for larger instances where global solvers may struggle.

5.3. General Quadratic Optimization

In our final experiment, we consider a general quadratic optimization problem:

minx≥0x⊤Qx+c⊤xs.t.Ax=b,(24)
where Q∈Rnx×nx is an indefinite matrix, and c∈Rnx, A∈Rmx×nx, and b∈Rmx are given.

From Theorem 2, we know that the above problem can be rewritten as

maxτ∈Rτs.t.∀x∈X, ∃(ux,wx):{12x⊤Q+x+12c⊤x−12ux⊤Q+ux+b⊤wx≥τ,A⊤wx−Q+ux≤Q−x+12c.(ARO-QO)
We examine three distinct versions of the ARO-QO algorithm, denoted as static ARO-QO, linear ARO-QO, and affine ARO-QO, each employing different decision policies. Static ARO-QO uses a static decision rule with ux=u and wx=w, linear ARO-QO employs a decision rule with ux=x and wx=w, and affine ARO-QO utilizes a special affine decision rule with ux=x and wx=Zx+z, where u∈Rnx, w∈Rmx, Z∈Rmx×nx, and z∈Rmx are static variables. To implement the ARO-QO algorithm and its variants, we use MOSEK as a convex optimization solver.

In Xia et al. (2020), the authors propose an exact MILO reformulation of Problem (24)

minx,μ,z,λ 12(c⊤x−b⊤μ)s.t.  Ax=b,2Qx+c+A⊤μ−λ=0,0≤xi≤ziUi,  i=1,…,nx,0≤λi≤(1−zi)Vi,  i=1,…,nx,z∈{0,1}nx.(MILO-QO)

This reformulation is based on the KKT conditions. The authors introduce binary variables z and big-M parameters (U and V) to linearize the nonconvex complementarity constraints in the KKT conditions. The parameters U∈Rnx and V∈Rnx are determined by solving a series of linear optimization problems. For a more detailed explanation of this reformulation technique, see Xia et al. (2020). In the remainder of this section, we consider (MILO-QO) as a benchmark approach and utilize Gurobi to solve it.

5.3.1. Problem Instances.

We generate a square matrix Q using the formula Q=PΛP⊤, where P is an orthogonal matrix obtained from the QR decomposition of a random matrix, and Λ is a diagonal matrix with components sampled uniformly from the interval [−5,5]. We know that (QO) is NP-hard even when Q has only one negative eigenvalue (Pardalos and Vavasis 1991). To explore the problem’s behavior across different scenarios, we generate Q in three cases based on its convexity rank (which we define as the number of positive eigenvalues). We consider low, medium, and high convexity ranks, corresponding to 10%, 50%, and 90% of the eigenvalues being positive, respectively. We also generate the matrix A and the vector c with components from the interval [−5,5] uniformly. To ensure the feasible region is bounded and feasible, we add a row of ones to the matrix A and set b≔A(12e).

5.3.2. Detailed Results.

We consider 15 groups, each of which contains five instances, with the dimension nx taking values in {20,50,100,200,1,000}. To ensure a large feasible set, we set the number of constraints mx to nx5. These test problems were generated using the mentioned pattern with the same convexity rank in each group.

The statistics of the results of solution gaps, optimality gaps, and solver times are presented in Table 5, where the first column in each represents the group of instances with the number of variables (nx), number of constraints (mx), and convexity rank of the matrix Q (p), respectively.

Table

Table 5. Statistics of Solution and Optimality Gaps and Solver Times for General Quadratic Optimization Instances

Table 5. Statistics of Solution and Optimality Gaps and Solver Times for General Quadratic Optimization Instances

Group (nx,mx,p)Static ARO-QO R2Static ARO-QO R3
OGapSGapTimeOGapSGapTime
#1 (20, 4, 0.10)137.61 [48.82]0.00 [0.00]0.06 [0.00]19.04 [5.43]0.00 [0.00]0.06 [0.00]
#2 (20, 4, 0.50)280.19 [73.76]2.32 [5.18]0.08 [0.05]48.11 [20.31]2.32 [5.18]0.07 [0.02]
#3 (20, 4, 0.90)833.48 [493.99]0.08 [0.17]0.15 [0.04]75.88 [41.82]0.08 [0.17]0.08 [0.01]
#4 (50, 10, 0.10)244.47 [26.88]0.98 [1.36]0.17 [0.03]50.27 [8.82]0.69 [1.33]0.17 [0.02]
#5 (50, 10, 0.50)449.48 [108.27]9.94 [13.52]0.25 [0.05]78.66 [12.53]0.89 [1.27]0.20 [0.03]
#6 (50, 10, 0.90)808.97 [502.13]1.89 [2.59]0.36 [0.11]116.58 [63.07]0.88 [1.97]0.23 [0.03]
#7 (100, 20, 0.10)340.16 [22.89]1.48 [2.63]0.42 [0.02]77.63 [11.08]0.30 [0.44]0.46 [0.02]
#8 (100, 20, 0.50)643.25 [107.03]7.36 [4.96]0.76 [0.12]144.03 [28.07]6.93 [6.82]0.66 [0.06]
#9 (100, 20, 0.90)1,276.85 [336.77]0.00 [0.00]0.77 [0.32]172.77 [40.76]5.73 [12.82]0.73 [0.25]
#10 (200, 40, 0.10)534.64 [12.50]0.99 [2.05]1.67 [0.17]144.53 [6.94]1.80 [2.47]1.95 [0.17]
#11 (200, 40, 0.50)930.02 [93.46]9.51 [14.14]1.95 [0.17]208.84 [21.82]5.56 [8.31]2.84 [0.52]
#12 (200, 40, 0.90)1,942.98 [277.56]0.00 [0.00]2.56 [0.60]259.38 [40.42]1.16 [2.58]4.08 [1.54]
#13 (1000, 200, 0.10)1,307.11 [34.89]1.89 [1.97]236.02 [14.89]389.64 [12.03]1.18 [1.78]248.70 [27.05]
#14 (1000, 200, 0.50)2,018.56 [113.24]5.61 [4.09]310.89 [55.01]511.58 [19.65]3.69 [3.73]381.05 [92.63]
#15 (1000, 200, 0.90)3,882.46 [240.03]0.00 [0.00]293.19 [45.45]538.49 [37.86]0.02 [0.04]359.27 [27.38]
Linear ARO-QOAffine ARO-QO
Group (nx,mx,p)OGapSGapTimeOGapSGapTime
#1 (20, 4, 0.10)19.03 [11.54]2.05 [4.34]0.06 [0.00]0.02 [0.05]0.00 [0.00]0.07 [0.01]
#2 (20, 4, 0.50)70.53 [37.49]3.74 [7.77]0.08 [0.03]23.02 [22.51]5.16 [7.81]0.10 [0.03]
#3 (20, 4, 0.90)541.08 [381.12]0.08 [0.17]0.14 [0.04]374.41 [376.78]0.00 [0.00]0.13 [0.02]
#4 (50, 10, 0.10)43.87 [8.87]0.55 [1.03]0.17 [0.03]3.92 [5.12]0.76 [1.48]0.74 [0.17]
#5 (50, 10, 0.50)92.78 [26.70]3.13 [5.39]0.26 [0.07]21.83 [19.78]4.01 [6.41]0.73 [0.08]
#6 (50, 10, 0.90)368.43 [225.03]1.43 [3.19]0.35 [0.10]179.62 [130.55]1.01 [2.25]0.81 [0.03]
#7 (100, 20, 0.10)70.12 [10.31]0.09 [0.12]0.43 [0.02]18.41 [14.43]4.01 [6.77]226.32 [431.55]
#8 (100, 20, 0.50)139.20 [15.40]0.03 [0.06]0.66 [0.11]56.04 [25.31]6.84 [10.65]103.21 [164.43]
#9 (100, 20, 0.90)573.13 [169.95]4.88 [10.92]0.78 [0.31]266.75 [93.59]0.00 [0.00]32.96 [5.69]
#10 (200, 40, 0.10)130.91 [5.08]1.01 [2.25]1.71 [0.27]60.60 [6.98]4.76 [6.09]3,000*
#11 (200, 40, 0.50)225.05 [35.68]7.49 [5.33]2.27 [0.64]104.62 [31.57]9.03 [10.92]3,000*
#12 (200, 40, 0.90)788.83 [153.96]6.83 [15.26]2.37 [0.39]390.98 [66.68]0.00 [0.00]3,000*
#13 (1000, 200, 0.10)357.28 [14.00]0.12 [0.22]263.10 [28.39]––3,000*
#14 (1000, 200, 0.50)496.19 [12.05]6.87 [2.93]320.57 [72.12]––3,000*
#15 (1000, 200, 0.90)1,275.71 [108.36]0.38 [0.85]279.80 [36.32]––3,000*
MILO-QOGurobi
Group (nx,mx,p)OGapSGapTimeOGapSGapTime
#1 (20, 4, 0.10)0.00 [0.00]0.00 [0.00]0.39 [0.04]0.00 [0.00]0.00 [0.00]0.11 [0.08]
#2 (20, 4, 0.50)0.00 [0.00]0.00 [0.00]0.40 [0.05]0.00 [0.00]0.00 [0.00]0.19 [0.15]
#3 (20, 4, 0.90)0.00 [0.00]0.00 [0.00]0.51 [0.11]0.01 [0.00]0.00 [0.00]6.38 [6.70]
#4 (50, 10, 0.10)0.00 [0.00]0.00 [0.00]360.72 [117.77]0.00 [0.00]0.00 [0.00]6.22 [4.21]
#5 (50, 10, 0.50)0.00 [0.00]0.00 [0.00]394.57 [146.07]0.00 [0.00]0.01 [0.02]35.55 [21.07]
#6 (50, 10, 0.90)30.85 [68.99]10.55 [23.60]1,508.81 [1,262.44]0.02 [0.03]0.00 [0.00]1,050.84 [1,203.60]
#7 (100, 20, 0.10)61,940.57 [4,389.58]88.45 [24.09]3,000*73.66 [39.67]16.44 [16.27]3,000*
#8 (100, 20, 0.50)––3,000*1,144.23 [324.05]10.08 [7.76]3,000*
#9 (100, 20, 0.90)––3,000*1,234.60 [466.02]0.00 [0.00]3,000*
#10 (200, 40, 0.10)––3,000*4,463.24 [403.29]16.02 [14.95]3,000*
#11 (200, 40, 0.50)––3,000*11,959.44 [1,780.21]5.40 [5.89]3,000*
#12 (200, 40, 0.90)––3,000*25,562.79 [3,323.87]1.41 [3.15]3,000*
#13 (1000, 200, 0.10)––3,000*––3,000*
#14 (1000, 200, 0.50)––3,000*––3,000*
#15 (1000, 200, 0.90)––3,000*––3,000*
CPLEXCPLEX Local
Group (nx,mx,p)OGapSGapTimeSGapTime
#1 (20, 4, 0.10)0.00 [0.00]0.00 [0.00]0.13 [0.06]30.14 [21.57]0.06 [0.06]
#2 (20, 4, 0.50)0.00 [0.00]0.00 [0.00]0.35 [0.37]15.82 [22.17]0.03 [0.00]
#3 (20, 4, 0.90)0.00 [0.00]0.00 [0.00]0.19 [0.08]0.00 [0.00]0.03 [0.00]
#4 (50, 10, 0.10)0.00 [0.00]0.00 [0.00]13.43 [10.56]31.01 [18.93]0.06 [0.01]
#5 (50, 10, 0.50)0.00 [0.00]0.01 [0.02]468.09 [764.65]12.37 [12.55]0.05 [0.00]
#6 (50, 10, 0.90)73.72 [84.39]0.88 [1.97]3,000*1.89 [2.59]0.04 [0.00]
#7 (100, 20, 0.10)239.12 [293.14]11.88 [11.41]3,000*33.38 [35.71]0.22 [0.11]
#8 (100, 20, 0.50)3,225.46 [423.43]8.42 [7.30]3,000*5.67 [6.78]0.11 [0.02]
#9 (100, 20, 0.90)10,943.59 [3,055.57]0.00 [0.00]3,000*0.00 [0.00]0.09 [0.02]
#10 (200, 40, 0.10)1,124.49 [62.94]10.67 [8.23]3,000*16.56 [5.91]1.13 [0.28]
#11 (200, 40, 0.50)8,056.26 [1,444.42]5.31 [6.89]3,000*5.01 [5.03]0.57 [0.13]
#12 (200, 40, 0.90)33,881.59 [3,944.54]2.95 [4.05]3,000*1.41 [3.15]0.32 [0.09]
#13 (1000, 200, 0.10)––3,000*10.88 [4.80]387.96 [77.99]
#14 (1000, 200, 0.50)––3,000*3.08 [3.54]186.89 [63.06]
#15 (1000, 200, 0.90)––3,000*0.02 [0.04]49.56 [18.36]


Notes. Problems are grouped by dimensions (nx, mx) and convexity rank (p) in the first column. Columns report “mean [standard deviation]” for solution/optimality gaps and solver times per subgroup. –, bounds not computed within the time limit. Bold denotes the best solution gap; underlined denotes the best optimality gap per group.

Static ARO-QO variants consistently outperform the CPLEX local search in terms of solution quality. Static ARO-QO with Representation 2 and Representation 3 achieve average solution gaps of 2.80% and 2.08%, respectively, compared with 11.15% for CPLEX local search across all instances. The superiority of static ARO-QO is further emphasized by the maximum solution gaps observed: 34.26% for Representation 2, 28.66% for Representation 3, and a substantial 92.53% for the CPLEX local search.

For smaller instances (Groups 1–6), all methods perform well, with MILO-QO, Gurobi, and CPLEX often achieving optimal solutions. The ARO methods show progressive improvement as their complexity increases from static to linear and then affine variants, specifically lower bound for low convexity rank groups.

For medium-sized instances (Groups 7–12), a significant performance shift becomes apparent. MILO-QO struggles, often failing to find solutions within the time limit. Although Gurobi and CPLEX do find solutions, they generally exhibit higher optimality gaps than the ARO-QO family. However, on larger problems, Gurobi and CPLEX outperform MILO-QO, frequently finding solutions where MILO-QO fails. The ARO-QO family consistently achieves lower optimality gaps more rapidly. For example, in Group 7, the ARO-QO family consistently outperforms all others in terms of both optimality and solution gaps while maintaining reasonable computation times. Specifically, affine ARO-QO achieves the best optimality gap, and linear ARO-QO achieves the best solution gap. In contrast, MILO-QO, Gurobi, and CPLEX struggle to find good solutions within the given time limit, demonstrating the superiority of the ARO-QO family for this group of instances.

The ARO-QO algorithm variants begin to outperform the MILO-QO reformulation and the global solvers Gurobi and CPLEX for medium-sized instances. This trend becomes even more evident for large instances (Groups 13–15), where only static ARO-QO and linear ARO-QO consistently provide solutions and lower bounds within acceptable solver times, whereas MILO-QO, Gurobi, and CPLEX fail to provide any solutions for these instances.

The impact of convexity rank is evident across all problem sizes. With increasing p, the function approaches convexity, making it easier to obtain a good solution, as shown in Table 5. In contrast, nonconvex QO problems with a lower convexity rank (i.e., a higher number of negative eigenvalues in Q) are generally more challenging to solve due to their complex landscape and the potential presence of multiple local optima, which complicates the search for the global optimum. However, a small value of p in ARO-QO often yields the best solutions as well. According to Section 5.1, we know that for p=0, ARO outperforms to finding near-optimal solutions and acceptable optimality gaps. The results demonstrate that for p=0.1, the optimality gap achieved by the ARO approaches remains small across all instances. As the problem size increases, and with lower p values, ARO methods maintain their effectiveness while other methods struggle or fail to provide viable solutions. This highlights the robustness of ARO approaches, especially in challenging scenarios where global solvers and MILO-QO reformulation falter. The consistent ability of ARO methods to deliver high-quality solutions with reasonable computational effort across diverse problem characteristics underscores their value in addressing complex quadratic optimization challenges.

6. Conclusions

We introduce a novel reformulation technique that enables the QO problem to be recast as an ARO problem. This process begins by demonstrating that any QO problem can be transformed into a disjoint biconvex QO problem. Following this, we propose an equivalent ARO reformulation. Specifically, we illustrate that employing a so-called decision rule technique to approximate the ARO reformulation equates to using a reformulation-linearization technique on original QO problem. The ARO reformulation offers a new approach to solving nonconvex QO problems by transferring the complexity from the original problem to its equivalent ARO counterpart. Specifically, in the concave QO problem, our ARO model transforms into a linear ARO, whereas in the indefinite QO problem, it becomes a nonlinear ARO. Moreover, we develop an algorithm capable of identifying near-optimal solutions using our novel reformulations. We demonstrate the effectiveness of our ARO-based method in solving a class of quadratic optimization problems through numerical experiments, showing that it can yield high-quality solutions with reasonable computational costs. This established connection between QO and ARO provides a new perspective on addressing the challenges of nonconvex QO problems and opens up new possibilities for further research in the field of mathematical optimization.

Acknowledgments

The authors thank Dick Den Hertog for insightful discussions and feedback and the anonymous reviewers whose comments improved the paper.

References

  • Ahmadi AA, Zhang J (2022) On the complexity of finding a local minimizer of a quadratic function over a polytope. Math. Programming 195(1):783–792.Crossref, Google Scholar
  • Andrianova A, Korepanova A, Halilova I (2016) One algorithm for branch and bound method for solving concave optimization problem. Proc. IOP Conf. Series: Materials Sci. and Engrg. (IOP Publishing, Bristol, UK), 012005.Crossref, Google Scholar
  • Anstreicher KM (2009) Semidefinite programming versus the reformulation-linearization technique for nonconvex quadratically constrained quadratic programming. J. Global Optim. 43:471–484.Crossref, Google Scholar
  • Anstreicher KM, Burer S (2005) DC versus copositive bounds for standard QP. J. Global Optim. 33(2):299–312.Crossref, Google Scholar
  • Ardestani-Jaafari A, Delage E (2021) Linearized robust counterparts of two-stage robust optimization problems with applications in operations management. INFORMS J. Comput. 33(3):1138–1161.Link, Google Scholar
  • Audet C, Hansen P, Savard G (2005) Essays and Surveys in Global Optimization, vol. 7 (Springer Science & Business Media, New York).Crossref, Google Scholar
  • Bao X, Sahinidis NV, Tawarmalani M (2011) Semidefinite relaxations for quadratically constrained quadratic programming: A review and comparisons. Math. Programming 129:129–157.Crossref, Google Scholar
  • Ben-Tal A, Roos E (2022) An algorithm for maximizing a convex function based on its minimum. INFORMS J. Comput. 34(6):3200–3214.Link, Google Scholar
  • Ben-Tal A, Goryashko A, Guslitzer E, Nemirovski A (2004) Adjustable robust solutions of uncertain linear programs. Math. Programming 99(2):351–376.Crossref, Google Scholar
  • Bentobache M, Telli M, Mokhtari A (2022) New LP-based local and global algorithms for continuous and mixed-integer nonconvex quadratic programming. J. Global Optim. 82(4):659–689.Crossref, Google Scholar
  • Bertsimas D, Bidkhori H (2015) On the performance of affine policies for two-stage adaptive optimization: A geometric perspective. Math. Programming 153(2):577–594.Crossref, Google Scholar
  • Bertsimas D, Caramanis C (2010) Finite adaptability in multistage linear optimization. IEEE Trans. Automatic Control 55(12):2751–2766.Crossref, Google Scholar
  • Bertsimas D, Dunning I (2016) Multistage robust mixed-integer optimization with adaptive partitions. Oper. Res. 64(4):980–998.Link, Google Scholar
  • Bertsimas D, Goyal V, Lu BY (2015) A tight characterization of the performance of static solutions in two-stage adjustable robust linear optimization. Math. Programming 150(2):281–319.Crossref, Google Scholar
  • Bertsimas D, Iancu DA, Parrilo PA (2010) Optimality of affine policies in multistage robust optimization. Math. Oper. Res. 35(2):363–394.Link, Google Scholar
  • Bhanja S, Karunaratne D, Panchumarthy R, Rajaram S, Sarkar S (2016) Non-Boolean computing with nanomagnets for computer vision applications. Nature Nanotech. 11(2):177–183.Crossref, Google Scholar
  • Bomze IM (2002a) Branch-and-bound approaches to standard quadratic optimization problems. J. Global Optim. 22:17–37.Crossref, Google Scholar
  • Bomze IM (2002b) Regularity versus degeneracy in dynamics, games, and optimization: A unified approach to different aspects. SIAM Rev. 44(3):394–414.Crossref, Google Scholar
  • Bomze IM (2015) Copositive relaxation beats Lagrangian dual bounds in quadratically and linearly constrained quadratic optimization problems. SIAM J. Optim. 25(3):1249–1275.Crossref, Google Scholar
  • Bomze IM, De Klerk E (2002) Solving standard quadratic optimization problems via linear, semidefinite and copositive programming. J. Global Optim. 24(2):163–185.Crossref, Google Scholar
  • Bomze I, Gabl M (2021) Interplay of non-convex quadratically constrained problems with adjustable robust optimization. Math. Methods Oper. Res. 93(1):115–151.Crossref, Google Scholar
  • Bomze IM, Locatelli M, Tardella F (2008) New and old bounds for standard quadratic optimization: Dominance, equivalence and incomparability. Math. Programming 115(1):31–64.Crossref, Google Scholar
  • Bomze IM, Schachinger W, Ullrich R (2018) The complexity of simple models—A study of worst and typical hard cases for the standard quadratic optimization problem. Math. Oper. Res. 43(2):651–674.Link, Google Scholar
  • Bonami P, Lodi A, Schweiger J, Tramontani A (2019) Solving quadratic programming by cutting planes. SIAM J. Optim. 29(2):1076–1105.Crossref, Google Scholar
  • Boyd SP, Vandenberghe L (2004) Convex Optimization (Cambridge University Press, Cambridge, UK).Crossref, Google Scholar
  • Bulo SR, Pelillo M, Bomze IM (2011) Graph-based quadratic optimization: A fast evolutionary approach. Comput. Vision Image Understanding 115(7):984–995.Crossref, Google Scholar
  • Bundfuss S, Dur M (2009) An adaptive linear approximation algorithm for copositive programs. SIAM J. Optim. 20(1):30–53.Crossref, Google Scholar
  • Burer S (2009) On the copositive representation of binary and continuous nonconvex quadratic programs. Math. Programming 120(2):479–495.Crossref, Google Scholar
  • Burer S, Vandenbussche D (2008) A finite branch-and-bound algorithm for nonconvex quadratic programming via semidefinite relaxations. Math. Programming 113(2):259–282.Crossref, Google Scholar
  • Burer S, Vandenbussche D (2009) Globally solving box-constrained nonconvex quadratic programs with semidefinite-based finite branch-and-bound. Comput. Optim. Appl. 43(2):181–195.Crossref, Google Scholar
  • Cen X, Xia Y (2021) A new global optimization scheme for quadratic programs with low-rank nonconvexity. INFORMS J. Comput. 33(4):1368–1383.Abstract, Google Scholar
  • Cevikalp H, Polikar R (2008) Local classifier weighting by quadratic programming. IEEE Trans. Neural Networks 19(10):1832–1838.Crossref, Google Scholar
  • Chen J, Burer S (2012) Globally solving nonconvex quadratic programming problems via completely positive programming. Math. Programming Comput. 4(1):33–52.Crossref, Google Scholar
  • Chinchuluun A, Pardalos PM, Enkhbat R (2005) Global minimization algorithms for concave quadratic programming problems. Optimization 54(6):627–639.Crossref, Google Scholar
  • Cuong TH, Lim Y, Yen ND (2024) On a solution method in indefinite quadratic programming under linear constraints. Optimization 73(4):1087–1112.Crossref, Google Scholar
  • De Ruiter FJ, Zhen J, Den Hertog D (2023) Dual approach for two-stage robust nonlinear optimization. Oper. Res. 71(5):1794–1799.Link, Google Scholar
  • Delage E, Iancu DA (2015) Robust multistage decision making. Aleman DM, Thiele AC, eds. Tutorials in Operations Research (INFORMS, Catonsville, MD), 20–46.Link, Google Scholar
  • Dorn WS (1960) Duality in quadratic programming. Quart. Appl. Math. 18(2):155–162.Crossref, Google Scholar
  • El Housni O, Goyal V (2021) On the optimality of affine policies for budgeted uncertainty sets. Math. Oper. Res. 46(2):674–711.Link, Google Scholar
  • Fampa M, Lee J, Melo W (2017) On global optimization with indefinite quadratics. EURO J. Comput. Optim. 5(3):309–337.Crossref, Google Scholar
  • Gibbons LE, Hearn DW, Pardalos PM, Ramana MV (1997) Continuous characterizations of the maximum clique problem. Math. Oper. Res. 22(3):754–768.Link, Google Scholar
  • Gökmen YG, Yıldırım EA (2022) On standard quadratic programs with exact and inexact doubly nonnegative relaxations. Math. Programming 193(1):365–403.Crossref, Google Scholar
  • Gondzio J, Yıldırım EA (2021) Global solutions of nonconvex standard quadratic programs via mixed integer linear programming reformulations. J. Global Optim. 81(2):293–321.Crossref, Google Scholar
  • Gorski J, Pfeuffer F, Klamroth K (2007) Biconvex sets and optimization with biconvex functions: A survey and extensions. Math. Methods Oper. Res. 66(3):373–407.Crossref, Google Scholar
  • Gouveia J, Pong TK, Saee M (2020) Inner approximating the completely positive cone via the cone of scaled diagonally dominant matrices. J. Global Optim. 76:383–405.Crossref, Google Scholar
  • Grippo L, Sciandrone M (2000) On the convergence of the block nonlinear Gauss–Seidel method under convex constraints. Oper. Res. Lett. 26(3):127–136.Crossref, Google Scholar
  • Gurobi Optimization (2023) LLC: Gurobi optimizer reference manual, version 10.0.0. Accessed January 14, 2024, http://www.gurobi.com.Google Scholar
  • Hadjiyiannis MJ, Goulart PJ, Kuhn D (2011) A scenario approach for estimating the suboptimality of linear decision rules in two-stage robust optimization. Proc. 50th IEEE Conf. Decision Control Eur. Control Conf. (IEEE, Piscataway, NJ), 7386–7391.Google Scholar
  • Hansen P, Jaumard B (1992) Reduction of indefinite quadratic programs to bilinear programs. J. Global Optim. 2:41–60.Crossref, Google Scholar
  • Horst R, Thoai NV (1999) DC programming: Overview. J. Optim. Theory Appl. 103:1–43.Crossref, Google Scholar
  • Hu J, Mitchell JE, Pang J-S (2012) An LPCC approach to nonconvex quadratic programs. Math. Programming 133(1–2):243–277.Crossref, Google Scholar
  • Ibaraki T, Katoh N (1988) Resource Allocation Problems: Algorithmic Approaches (MIT Press, Cambridge, MA).Google Scholar
  • IBM (2019) IBM ILOG CPLEX optimization studio user’s manual, version 12.9.0 (1987-2019). Accessed January 14, 2024, https://www.ibm.com.Google Scholar
  • Khademi A, Marandi A (2025) Quadratic optimization through the lens of adjustable robust optimization. https://github.com/INFORMSJoC/2024.0577, https://doi.org/10.1287/ijoc.2024.0577.cd.Google Scholar
  • Khademi A, Marandi A, Soleimani-Damaneh M (2024) A new dual-based cutting plane algorithm for nonlinear adjustable robust optimization. J. Global Optim. 89(3):559–595.Crossref, Google Scholar
  • Khadivar F, Chatzilygeroudis K, Billard A (2023) Self-correcting quadratic programming-based robot control. IEEE Trans. Systems Man Cybernetics 53(8):5236–5247.Crossref, Google Scholar
  • Kim S, Kojima M, Toh K-C (2020) A geometrical analysis on convex conic reformulations of quadratic and polynomial optimization problems. SIAM J. Optim. 30(2):1251–1273.Crossref, Google Scholar
  • Konno H (1976) A cutting plane algorithm for solving bilinear programs. Math. Programming 11(1):14–27.Crossref, Google Scholar
  • Kozlov MK, Tarasov SP, Khachiyan LG (1980) The polynomial solvability of convex quadratic programming. USSR Comput. Math. Math. Phys. 20(5):223–228.Crossref, Google Scholar
  • Lipp T, Boyd S (2016) Variations and extension of the convex–Concave procedure. Optim. Engrg. 17:263–287.Crossref, Google Scholar
  • Liuzzi G, Locatelli M, Piccialli V (2019) A new branch-and-bound algorithm for standard quadratic programming problems. Optim. Methods Software 34(1):79–97.Crossref, Google Scholar
  • Löfberg J (2004) YALMIP: A toolbox for modeling and optimization in MATLAB. Proc. CACSD Conf. (IEEE, Piscataway, NJ).Google Scholar
  • Luo H, Bai X, Lim G, Peng J (2019) New global algorithms for quadratic programming with a few negative eigenvalues based on alternative direction method and convex relaxation. Math. Programming Comput. 11(1):119–171.Crossref, Google Scholar
  • Markowitz HM (1952) Protfilio selection. J. Finance 7(1):77–91.Google Scholar
  • Mitchell JE, Pang J-S, Yu B (2014) Convex quadratic relaxations of nonconvex quadratically constrained quadratic programs. Optim. Methods Software 29(1):120–136.Crossref, Google Scholar
  • MOSEK ApS (2023) The MOSEK optimization toolbox for MATLAB manual, version 10.1.15. Accessed January 14, 2024, https://www.mosek.com/.Google Scholar
  • O’Nan M (1971) Linear Algebra, Eagle Mathematics Series (Harcourt Brace Jovanovich, New York).Google Scholar
  • Pardalos PM, Schnitger G (1988) Checking local optimality in constrained quadratic programming is NP-hard. Oper. Res. Lett. 7(1):33–35.Crossref, Google Scholar
  • Pardalos PM, Vavasis SA (1991) Quadratic programming with one negative eigenvalue is NP-hard. J. Global Optim. 1(1):15–22.Crossref, Google Scholar
  • Phillips AT, Rosen JB (1988) A parallel algorithm for constrained concave quadratic global minimization. Math. Programming 42:421–448.Crossref, Google Scholar
  • Postek K, Hertog D D (2016) Multistage adjustable robust mixed-integer optimization via iterative splitting of the uncertainty set. INFORMS J. Comput. 28(3):553–574.Link, Google Scholar
  • Renegar J (2001) A Mathematical View of Interior-Point Methods in Convex Optimization (SIAM, Philadelphia).Crossref, Google Scholar
  • Rostami B, Errico F, Lodi A (2023) A convex reformulation and an outer approximation for a large class of binary quadratic programs. Oper. Res. 71(2):471–486.Link, Google Scholar
  • Sahni S (1974) Computationally related problems. SIAM J. Comput. 3(4):262–279.Crossref, Google Scholar
  • Scozzari A, Tardella F (2008) A clique algorithm for standard quadratic programming. Discrete Appl. Math. 156(13):2439–2448.Crossref, Google Scholar
  • Selvi A, den Hertog D, Wiesemann W (2023) A reformulation-linearization technique for optimization over simplices. Math. Programming 197(1):427–447.Crossref, Google Scholar
  • Selvi A, Ben-Tal A, Brekelmans R, den Hertog D (2022) Convex maximization via adjustable robust optimization. INFORMS J. Comput. 34(4):2091–2105.Link, Google Scholar
  • Sherali HD, Alameddine A (1992) A new reformulation-linearization technique for bilinear programming problems. J. Global Optim. 2:379–410.Crossref, Google Scholar
  • Sherali H, Liberti L (2009) Reformulation-linearization methods for global optimization. Encyclopedia of Optimization (Springer, Boston), 3263–3268.Google Scholar
  • Sherali HD, Tuncbilek CH (1995) A reformulation-convexification approach for solving nonconvex quadratic programming problems. J. Global Optim. 7:1–31.Crossref, Google Scholar
  • Thomä S, Walther G, Schiffer M (2024) Designing tractable piecewise affine policies for multi-stage adjustable robust optimization. Math. Programming 208(1):661–716.Crossref, Google Scholar
  • Wang AL, Kılınç-Karzan F (2022) On the tightness of SDP relaxations of QCQPs. Math. Programming 193(1):33–73.Crossref, Google Scholar
  • Wolkowicz H, Saigal R, Vandenberghe L (2012) Handbook of Semidefinite Programming: Theory, Algorithms, and Applications, vol. 27 (Springer Science & Business Media, Kluwer Academic Publishers, Boston).Google Scholar
  • Xia W, Vera JC, Zuluaga LF (2020) Globally solving nonconvex quadratic programs via linear integer programming techniques. INFORMS J. Comput. 32(1):40–56.Link, Google Scholar
  • Yanıkoğlu İ, Gorissen BL, den Hertog D (2019) A survey of adjustable robust optimization. Eur. J. Oper. Res. 277(3):799–813.Crossref, Google Scholar
  • Zamani M (2023) New bounds for nonconvex quadratically constrained quadratic programming. J. Global Optim. 85(3):595–613.Crossref, Google Scholar
  • Zhen J, Den Hertog D, Sim M (2018) Adjustable robust optimization via Fourier–Motzkin elimination. Oper. Res. 66(4):1086–1100.Link, Google Scholar
  • Zhen J, Marandi A, de Moor D, den Hertog D, Vandenberghe L (2022) Disjoint bilinear optimization: A two-stage robust optimization perspective. INFORMS J. Comput. 34(5):2410–2427.Link, Google Scholar
  • Zheng XJ, Sun XL, Li D (2011) Convex relaxations for nonconvex quadratically constrained quadratic programming: Matrix cone decomposition and polyhedral approximation. Math. Programming 129(2):301–329.Crossref, Google Scholar