On cutting planes for cardinality-constrained linear programs

Abstract

We derive cutting planes for cardinality-constrained linear programs. These inequalities can be used to separate any basic feasible solution of an LP relaxation of the problem, assuming that this solution violates the cardinality requirement. To derive them, we first relax the given simplex tableau into a disjunctive set, expressed in the space of nonbasic variables. We establish that coefficients of valid inequalities for the closed convex hull of this set obey ratios that can be computed directly from the simplex tableau. We show that a transportation problem can be used to separate these inequalities. We then give a constructive procedure to generate violated facet-defining inequalities for the closed convex hull of the disjunctive set using a variant of Prim’s algorithm.

Appendix: Proof of Theorem 4

Proof

For a given node set $X\subseteq \mathbf{{\mathcal {N}}_0}$, the operation Extract-Min(X) (resp. Extract-Max(X)) removes and returns the element of X with the smallest (resp. largest) key. We also define $\text {Min}(X):=\min _{i\in X}\text {key}[i]$ and $\text {Max}(X):=\max _{i\in X}\text {key}[i]$. We denote by ${\mathcal {Q}}_+$ (resp. ${\mathcal {Q}}_-$) the max-priority queue in ${\mathcal {I}}_+$ (resp. min-priority queue in ${\mathcal {I}}_-$) whose keys are not yet finalized. We let ${\mathcal {Q}}={\mathcal {Q}}_+\cup {\mathcal {Q}}_-$. For a node v, $\text {Adj}[v]$ is the set of nodes adjacent to v in ${\mathcal {Q}}$.

Let H represent the sequence of nodes extracted during the successive iterations of the while loop. For nodes i and j, we write $j \prec i$ if j occurs in H before i. We define $\text {key}[0]=0$. Then, for $i\in {\mathcal {Q}}_+$ (resp. ${\mathcal {Q}}_-\backslash \{0\}$), we define $\text {key}[i]$ to be $\max _{j\in {\mathcal {I}}_-\backslash {\mathcal {Q}}_-, j \prec i} -s_{ij} + \text {key}[j]$ (resp. $\min _{j\in {\mathcal {I}}_+\backslash {\mathcal {Q}}_+, j\prec i} s_{ij}+\text {key}[j]$). We use induction to show that keys follow this definition. The base case can be verified via the initial assignment of keys and the convention that $\min \{\emptyset \}=\infty$. If we assume that the keys satisfy the above definition before the iteration, then since $k\prec i$ for any $i\in {\mathcal {Q}}\backslash \{k\}$, the definition remains valid after the step 11 (resp. step 13). It is clear that once a node is extracted, the key of the node never changes in the remainder of the algorithm.

We first show that $\min ({\mathcal {Q}}_-)-\text {key}[k]\ge 0$ and $\text {key}[k] - \max ({\mathcal {Q}}_+)\ge 0$ at step 4 of the algorithm. This is clearly true for the base case. We assume that these inequalities are true and we choose to extract $k'$ at either step 5 or step 7. We will only argue that the above inequalities hold for $k'$ selected at step 5 because the other case is similar. We first argue that the result holds before step 9. If $k'$ was selected at step 5, i.e., $k'\in {\mathcal {Q}}_-$, then the first inequality holds because $k'$ was chosen to be the node with minimum key in ${\mathcal {Q}}_-$. The second inequality holds because $\text {key}[k']-\text {key}[k]\ge 0$ and $\text {key}[k]-\max ({\mathcal {Q}}_+)\ge 0$ by induction hypothesis. Now, we show that these inequalities continue to hold until the step 4 of the next iteration. In particular, observe that for $j\in {\mathcal {Q}}_-$ (resp. $j\in {\mathcal {Q}}_+$), since $\text {key}[j]\ge \text {key}[k']$ (resp. $\text {key}[j]\le \text {key}[k']$) before the update in step 13 (resp. step 11) and $s_{jk'}\ge 0$, it remains so after the update as well.

Now, we show that at each iteration of the algorithm where node $k'$ is extracted, $\delta + \sum _{j \preceq k'} \text {key}[j]\chi (\{j\}) + \text {key}[k']\chi ({\mathcal {Q}})$ defines a valid cut. This is trivially true for the base case. We now consider the case when $k'$ is extracted. The incremental change to the vector is $(\text {key}[k']-\text {key}[k])\chi ({\mathcal {Q}}\cup \{k'\})$, where k immediately precedes $k'$ in H. Clearly, this change does not affect any inequality in $D_{1}$ expressed for nodes i and j which both precede $k'$ or both succeed $k'$. Therefore, we only need to concern ourselves with an inequality with respect to i and j where $i\preceq k'\preceq j$. Assume $j\in {\mathcal {Q}}_+$. If $k'\in {\mathcal {I}}_+$, then the result follows because $0\le s_{ij} + \text {key}[j] - \text {key}[i] \le s_{ij} + \text {key}[k'] - \text {key}[i]$ because $k'$ is the maximizer in ${\mathcal {Q}}_+$. On the other hand, if $k'\in {\mathcal {I}}_-$, then $s_{ij} + \text {key}[k'] - \text {key}[i] \ge 0$ if $k'=i$ and $s_{ij} + \text {key}[k'] - \text {key}[i] \ge s_{ij} + \text {key}[k] - \text {key}[i] \ge 0$, where the first inequality follows because $\text {key}[k']-\text {key}[k]\ge 0$ by our earlier proof and the second inequality by the induction hypothesis and because $\text {key}[i]$ was not updated. The proof for the case $j\in {\mathcal {Q}}_-$ is similar.

It follows from the definition of keys that at least one of the inequalities with respect to $k'$ and its predecessors becomes tight. Since the procedure only stops when all the nodes are visited, it follows that the graph of tight inequalities is connected at the end and $\delta + \sum _{j\in \mathbf{{\mathcal {N}}_0}} \text {key}^*[j]\chi (\{j\})$ defines a facet-defining inequality.

We now show that all the tight inequalities remain tight during the procedure. In particular, assume $s_{ij} = 0$. Assume $j\preceq i$ where $j\in {\mathcal {I}}_-$ (the proof for $j \in {\mathcal {I}}_+$ is similar). Clearly, when $k=j$ at step 4, $\text {key}[j]\ge \text {key}[i]$. However, $\text {key}[i]\ge \text {key}[j]$ because of the previous update at step 11. Therefore, $\text {key}[j]-\text {key}[i]=0$. Then, because of the condition in step 4, the keys added match $\text {key}[i]$. Therefore, there is no update to $\text {key}[i]$ because $\text {key}[i]\ge -s_{ik} + \text {key}[k]$ follows from $s_{ik}\ge 0$ and $\text {key}[i]=\text {key}[k]$.

The above algorithm can be implemented using heaps for both ${\mathcal {Q}}_+$ and ${\mathcal {Q}}_-$. If the graph $G({\mathcal {I}}_+,{\mathcal {I}}_-)$ has n nodes and e edges, it requires O(n) Insert, O(n) Min, O(n) Max, O(n) Extract-Min and Extract-Max, and O(e) Decrease-Key operations. With Fibonacci heaps, the running time is $O(e+n\log n)$ which exactly matches that of Prim’s algorithm. $\square$