Packing Under Convex Quadratic Constraints

Abstract

We consider a general class of binary packing problems with a convex quadratic knapsack constraint. We prove that these problems are APX-hard to approximate and present constant-factor approximation algorithms based upon three different algorithmic techniques: (1) a rounding technique tailored to a convex relaxation in conjunction with a non-convex relaxation whose approximation ratio equals the golden ratio; (2) a greedy strategy; (3) a randomized rounding method leading to an approximation algorithm for the more general case with multiple convex quadratic constraints. We further show that a combination of the first two strategies can be used to yield a monotone algorithm leading to a strategyproof mechanism for a game-theoretic variant of the problem. Finally, we present a computational study of the empirical approximation of the three algorithms for problem instances arising in the context of real-world gas transport networks.

We acknowledge funding through the DFG CRC/TRR 154, Subproject A007.

Appendix A – Computational results

We apply our algorithms to gas transportation as described in Example 1, using the GasLib-134 instance [25], see Fig. 2. Sources and sinks are denoted by S and T, resp. Every $t\in T$ has a demand of $q_t$ units of gas. To ensure network robustness in the sense of [14], we assume that all sinks between $s_1$ and $s_2$ are supplied by $s_1$, all sinks between $s_3$ and $t_{45}$ by $s_3$, and all other sinks by $s_2$. Let $T_i$ be the sinks supplied by $s_i$. For simplicity, we assume that for every $t\in T$, the economic welfare $p_t$ of transporting $q_t$ units of gas to t equals $\theta q_t$ for $\theta > 0$.

The goal is to choose a welfare-maximal feasible subset of transportations, while the pressures at the first sink $s_1$ and the last source $t_{45}$ are within their feasible interval. Let $\bar{E}$ denote the path from $s_1$ to $t_{45}$, and for every $t\in T_i$ denote by $E_t$ the set of edges on the unique path from $s_i$ to t, $i \in [3]$. Let $p = (p_t)_{t\in T}$, $W = (w_{t,t'})_{t,t'\in T}$, with $w_{t,t'} = \sum _{e\in \bar{E} \cap E_t\cap E_{t'}}\beta _e\, q_t\, q_{t'}$, and let , where $\bar{\pi }_v$ and denote the upper and lower bound on the squared pressure at node v, respectively. Finally, let $x = (x_t)_{t\in T} \in \{0,1\}^T$, where $x_t = 1$ if and only if sink t is supplied. This results in a formulation as (P); see Example 1.

Fig. 2.

The Gaslib-134 instance. Sources are shown in blue, sinks in red. (Color figure online)

The GasLib-134 instance contains different scenarios, where each scenario provides demands $\hat{q}_t$ for every sink $t\in T$. In order to make the optimization problem non-trivial, we increase the node demands by setting $q_t = \gamma \, \hat{q}_t$, for . We apply the golden ratio, greedy, and randomized rounding algorithm to the first 100 scenarios, using each $\gamma \in \varGamma$. The algorithms are executed using k initial elements in partial enumeration for each $k \in \{0,1,3\}$.

Table 1. Mean and standard deviation (SD) of the approximation ratio of the greedy algorithm, the golden ratio algorithm, and randomized rounding. Each algorithm has been executed with partial enumeration of k elements.

Fig. 3.

Approximation ratios (top row) and computation times (bottom row) of the three algorithms when executed with partial enumeration of $k = 0, 1, 3$ elements. The red line indicates the median. (Color figure online)

Randomized rounding is run with $\alpha$ chosen uniformly at random from [0, 1]. Instead of a single feasible realization, we generate 100 feasible realizations of and return the one with the highest profit. For the golden ratio algorithm, instead of scaling the optimal solution y of (${R_1}$) by $\phi$, we scale it by the largest number $\lambda \in [\phi ,1]$ such that $\lambda \, y$ is feasible for (${R_2}$), using binary search. The result of each algorithm is compared to an optimal solution computed with a standard MIP solver. The computations were executed on a 4-core Intel Core i5-2520M processor with 2.5 GHz. The code is implemented in Python 3.6 and we use the SLSQP algorithm of the SciPy optimize package to solve (${R_1}$). The results are shown in Table 1 and as box plots in Fig. 3.

The greedy algorithm achieves the best approximation ratios on average when combined with partial enumeration and is at least 20 times faster than the other algorithms, because the latter rely on solving (${R_1}$) first. The approximation ratio of all three algorithms is on average much higher than their proven worst case lower bounds. However, the quality of the solutions produced by the golden ratio algorithm is subject to strong fluctuations. By running the algorithm with partial enumeration with $k = 3$ initial items, the ratio is at least $\phi$ for every instance, as guaranteed by Theorem 1.