On the exact separation of cover inequalities of maximum-depth

We investigate the problem of separating cover inequalities of maximum-depth exactly. We propose a pseudopolynomial-time dynamic-programming algorithm for its solution, thanks to which we show that this problem is weakly NP\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\mathcal {N}}{\mathcal {P}}$$\end{document}-hard (similarly to the problem of separating cover inequalities of maximum violation). We carry out extensive computational experiments on instances of the knapsack and the multi-dimensional knapsack problems with and without conflict constraints. The results show that, with a cutting-plane generation method based on the maximum-depth criterion, we can optimize over the cover-inequality closure by generating a number of cuts smaller than when adopting the standard maximum-violation criterion. We also introduce the Point-to-Hyperplane Distance Knapsack Problem (PHD-KP), a problem closely related to the separation problem for maximum-depth cover inequalities, and show how the proposed dynamic programming algorithm can be adapted for effectively solving the PHD-KP as well.


Introduction
The separation of maximum-violation inequalities is the standard approach for generating valid inequalities in Mixed Integer Linear Programs (MILPs) [33]. In the literature, however, some authors have speculated that separating (fractional) solutions by using a criterion different from maximizing the cut violation could be beneficial for the performance of the cutting-plane methods [1,3,4,6,7,14]. The maximization of the cut depth [6] (also referred to as "geometric distance" [7] or "efficacy" [4,11]) is one such criterion. It is, in particular, one of the criteria used in, e.g., SCIP during the cutselection phase in which a subset of cuts is selected from the cut pool to be added to strengthen the formulation of the problem [1]. Previous works, including [28,34,37], tackled the problem of separating inequalities of maximum depth only heuristically, due to its intrinsic difficulty.
In this work, we focus on the case of cover inequalities and address the problem of their exact separation according to the maximum-depth criterion. The main theoretical result of our paper (see Sect. 5) is the characterization of the computational complexity of this problem. To this end, we develop an exact pseudopolynomial-time dynamic programming algorithm by means of which we show that the maximum-depth separation problem is weakly N P-hard. This result shows that, even if it entails (as we will show) the optimization of a hyperbolic objective function, the complexity class of this separation problem is the same as for the standard one based on the maximumviolation criterion. A second contribution of the paper (see Sect. 6) is the introduction of the Point-to-Hyperplane Distance Knapsack Problem (PHD-KP), which, similarly to the problem of separating maximum-depth inequalities, is a knapsack problem with a hyperbolic objective function. We show that even this problem is weakly N P-hard and that it can be solved by an adaptation of the dynamic programming algorithm we propose for the separation problem of maximum depth.
Computational experiments (see Sect. 7) carried out on several classes of instances reveal that the adoption of the cut depth allows for optimizing over the cover-inequality closure by generating a number of cuts smaller than with the standard maximumviolation criterion. Interestingly, our experiments also reveal that a reduction in the number of cutting planes, inferior but similar to the one achieved with the maximumdepth criterion, can be obtained by separating maximum-violation inequalities and making the corresponding covers minimal via an a posteriori procedure. Finally, computational experiments (see Sect. 8) on several classes of PHD-KP instances show that our dynamic-programming algorithm can solve the problem more efficiently than a state-of-the-art nonlinear-programming solver.
where each variable y j ∈ {0, 1} encodes the decision of inserting (or not) item j ∈ N into the knapsack. 1 One (or several) such constraints are present in countless real-world applications involving the solution of a MILP [23][24][25]30].
A cover is a subset of items C ⊂ N with a total weight exceeding the knapsack capacity. This notion plays a central role in determining strong valid inequalities for the convex hull of the solutions to optimization problems featuring one or more knapsack constraints. In particular, since no more than |C| − 1 items of a given cover C ⊂ N can be simultaneously inserted into the knapsack, the following family of constraints, called cover inequalities, are valid for the convex hull of the problem: In either its original form (1) or in its lifted form (see the survey [23]), this exponentially-large family of constraints constitutes one of the earliest combinatorial inequalities adopted in a general-purpose 0-1 Integer Programming (IP) solver [17], and it it still routinely generated (heuristically) in most state-of-the-art MILP solvers. Given a (fractional) pointȳ ∈ [0, 1] n , the Separation Problem (SP) for the cover inequalities calls for an inequality of type (1) with a strictly positive cut violation, i.e., with j∈Cȳ j − |C| + 1 > 0, or for a proof that no such inequality exists. The standard solution approach for solving the SP consists in searching for a cover with a cut violation as large as possible. By introducing, for each j ∈ N , a decision variable z j ∈ {0, 1} equal to 1 if and only if item j belongs to the cover, this problem can be formulated in terms of the following Integer Linear Program (ILP): By complementing the z variables, i.e., by introducing a new set of x variables such that x j := 1 − z j for each j ∈ N , the Maximum-Violation Separation Problem (MV-SP) can be formulated in terms of the following Knapsack Problem (KP): where q j := 1 −ȳ j , for all j ∈ N , Ψ := j∈Nȳ j − n + 1, Φ := j∈N w j − (c + 1). We refer to v as the maximum cut violation. Let x * denote an optimal solution to the (MV-SP) and let C * := { j ∈ N : x * j = 0}. If v > 0, the cover inequality corresponding to C * is maximally violated byȳ, whereas, if v ≤ 0, we have a proof that no violated cover inequality exists.

On the maximum-depth cover inequalities
Given a cover C ⊂ N , let be the hyperplane consisting in the set of points y ∈ R n for which the inequality j∈C y j ≤ |C| − 1 is tight. Given a pointȳ ∈ [0, 1] n , the depth of the cover inequality corresponding to C is defined as the Euclidean (or 2-norm) point-to-hyperplane distance betweenȳ and the point belonging to H C that is closest toȳ in Euclidean norm-such a point is often called the projection ofȳ onto H C . We denote this distance by d 2 (ȳ, H C ). Letting z ∈ {0, 1} n be the characteristic vector of C, we have: where ||z|| 2 is the Euclidean norm (or 2-norm) of z. A derivation of this classical result using the tools of nonlinear optimization can be found in [29]. Besides the aforementioned works belonging to the cutting-plane literature in which the cut depth has been adopted, articles in which such a distance is either maximized or minimized include [2,10,13]. We report an illustration in the following example.
The separation problem calling for a cover inequality of maximum Euclidean-norm point-to-hyperplane distance, i.e., of maximum depth, can be cast as the following Mixed Integer Non-Linear Program (MINLP): We call the corresponding problem the Maximum-Depth Separation Problem (MD-SP). The objective function, obtained from (2) by dropping the absolute value, corresponds to the opposite of the signed 2-norm point-to-hyperplane distance between y and the set of all points y ∈ R n that satisfy the cover inequality induced by C := { j ∈ N : z j = 1}. Thus, it is equal to −d 2 (ȳ, H C ) ifȳ satisfies such an inequality, and to d 2 (ȳ, H C ) otherwise.
Since the z variables are binary, ||z|| 2 = j∈N |z j | 2 = j∈N z j . Complementing such variables as before, i.e., by introducing a binary variable x j := 1 − z j for each j ∈ N , we obtain the following equivalent MINLP formulation: The irrationality of the objective function prevents us from solving the problem exactly (i.e., up to an infinite precision) on a Turing machine. However, by discarding the solutions to the problem having a non-positive violation, we can, without loss of generality, raise the objective function to the second power. We obtain the following problem: where d is the square of the maximum cut-depth. Let x * be an optimal solution to the (MD-SP) and let C * := { j ∈ N : x * j = 0}. If the problem is feasible, which implies d > 0, C * corresponds to a violated cover inequality of maximum depth. In contrast, if the problem is infeasible, we have a proof that no violated cover inequality exists. We note that the objective function is well-defined as its denominator is equal to 0 only for x j = 1 for all j ∈ N , which is infeasible because j∈N w j Ψ = j∈N w j − (c + 1).

On the nature of cover inequalities of maximum-depth
The (MD-SP) can be interpreted as a variant of the (MV-SP) in which, rather than a single objective function, the ratio of two different objective functions is maximized: the item profit incremented by the constant Ψ (squared) and the cardinality of the cover, which corresponds to the difference between n and the number of items contained in a solution to the (MD-SP). Due to this ratio, in the (MD-SP) we look for solutions with a large numerator and a small denominator. This results in a non-concave objective function, as shown in Fig. 2. It is well-known that a cover inequality is non-dominated whenever the corresponding cover C is inclusion-wise minimal, i.e., whenever, for any j ∈ C, C \ { j} is not a cover. When separating maximum-depth cover inequalities, the presence of the denominator of the (MD-SP) implies the following:

Proposition 1 Any cover corresponding to an optimal solution to the (MD-SP) is minimal.
Proof Let x * be an optimal solution to the (MD-SP) and let C * := { j ∈ N : x * j = 0} be the corresponding cover. If C * is not minimal, there exists a minimal coverC with C ⊂ C * . Letx j ∈ {0, 1} n such thatC = { j ∈ N :x j = 0}. AsC ⊂ C * , there is some j ∈ N with j ∈ C * and j / ∈C. Thus, x * j = 0 andx j = 1, implying thatx achieves a numerator at least as large as x * and a strictly smaller denominator, which shows that x * is not optimal.
Besides this minimality property, the (MD-SP) establishes a trade-off between the cut violation (in the numerator) and the cardinality of the cover (in the denominator), often leading to solutions with a less-than-optimal violation which is compensated by a smaller cardinality. This is illustrated by the following numerical example, which also shows how the optimal solutions to the (MD-SP) and the (MV-SP) can be different even when they correspond to minimal covers. ≈ 0.026). This difference is due to the fact that, in the (MD-SP), the smaller numerator of {1, 3} is compensated by a smaller denominator, whereas {4}, which has a larger numerator, is penalized by a larger denominator.

An exact dynamic programming algorithm for the (MD-SP)
In this section, we discuss the computational complexity of the (MD-SP) and we present a solution algorithm based on Dynamic Programming (DP) to solve it to optimality. Thanks to such an algorithm, we also show that the problem is weakly N P-hard.
The denominator of the objective function of the (MD-SP) takes discrete values in the set {1, . . . , n − 1} (recall that the (MD-SP) is infeasible for k = n) as a function of the number of items in the solution. It is not difficult to see that, by removing any item j from an optimal solution with k ∈ {1, . . . , n − 1} items, the remaining set of items in the solution must be optimal for the subproblem with capacity Φ − w j , item set N \ { j}, and containing k − 1 items, as, if not, the solution with k items is not optimal. Thus, the (MD-SP) exhibits the so-called optimal-substructure property, which can be exploited by an approach relying on Bellman's recursion [25,30].
Based on this observation, we now derive a Dynamic Programming (DP) algorithm for the (MD-SP). For each item j ∈ N , integer k ∈ {1, . . . , n − 1}, and capacity value s ∈ {0, . . . , Φ}, we denote by f k j (s) the maximum total profit in terms of the q values increased by the constant Ψ (this corresponds to the numerator of the objective function of (MD-SP)) that is achievable by choosing k items belonging to {1, . . . , j} ⊆ N with a total weight no larger than s ≤ Φ. The following proposition holds:

Proposition 2
The (MD-SP) can be solved in O(n 2 Φ), and its optimal solution value is: whereas, if f k n (Φ) ≤ 0 for all k ∈ {1, . . . , n − 1}, the (MD-SP) is infeasible. Proof For j = 1 and s ∈ {0, . . . , Φ}, the following holds for all k ∈ {1, . . . , n − 1}: The last case is due to the fact that no more than a single item can be chosen for j = 1. As a consequence of the pseudopolynomial-time dynamic programming algorithm illustrated in Proposition 2, the following holds: Proof The separation problem calling for a cover inequality of strictly positive violation (or for a proof that no such inequality exists) is known to be weakly N P-hard [26]. As any algorithm for the solution of the (MD-SP) implicitly solves such a separation problem as well, the (MD-SP) is at least weakly N P-hard. As the DP algorithm we proposed runs in pseudopolynomial time, we deduce that the problem is weakly N P-hard.
We note that it is not necessary to compute f k j (s) for all the values of k ∈ {1, . . . , n− 1}. In fact, it suffices to consider k ∈ {1, . . . ,k} wherē This value can be computed in O(n log n) by sorting the items in N in non-increasing order of weights and by adding them to the solution in that order until the capacity Φ is saturated. This observation reduces the complexity of the algorithm to O(nk Φ).
An additional further speed-up can be obtained by considering, in the recursion, values of k up to the minimum betweenk and the index j of the item currently under examination. We conclude this section by showing an example of execution of the DP algorithm.

Example 3
Consider again the instance of Example 2, with n = 4, weights w 1 = 3, The maximum number of items that can be simultaneously chosen isk = 2. The values of the recursive function f k j (s) are shown in Table 1. For each item j ∈ N , the values corresponding to k > j (which can be neglected) are denoted by "-". In order to retrieve the optimal solution value, it is sufficient to examine the values of f j (s) k for j = 4 (the last item) and s = Φ = 5 for all the values of k. In

The point-to-hyperplane distance knapsack problem
In this section, we extend our study by introducing a problem related to the (MD-SP) which arises when maximizing a hyperbolic function over the feasible region of the knapsack problem, and show that the DP algorithm presented in Sect. 5 can be easily adapted to also solve such a problem. Given a set of items S ⊆ N , let y be the characteristic vector of S. For any ∈ N ∪ {∞}, we denote by ||y|| the -norm of y, defined as ||y|| = n j=1 |y j | = n j=1 y j , if ∈ N, and ||y|| = lim →∞ n j=1 |y j | = max j∈1,...,n |y j |, if = ∞. We introduce the following problem: Point-to-Hyperplane Distance Knapsack Problem. Given a set N of n items, a weight w j ∈ Z + , a profit p j ∈ Z + for each item j ∈ N , a knapsack capacity c ∈ Z + , a constant α ∈ Z − , and a (non-necessarily finite) positive integer ∈ N ∪ {∞}, find a subset of items S ⊆ N of total weight w(S) := j∈S w j no larger than c and of Table 1 Execution of the DP algorithm on the instance of Example 3 nonnegative total profit p(S) := j∈S p j + α such that ratio between p(S) and ||y|| is maximized. 2 The problem calls for the maximization of the opposite of the signed -norm pointto-hyperplane distance between the point p (i.e., the profit vector) and the hyperplane H S := y ∈ R n : j∈S y j + α = 0 . Such a distance reads j∈N p j y j + α ||y|| , where and satisfy 1 + 1 = 1 (the corresponding norms are dual in the sense of Hölder's inequality). Figure 3 provides a geometric insight of such a signed distance. By using an approach similar to the one that led to definition of the (MD-SP) in Sect. 3, we directly cast the Point-to-Hyperplane Distance Knapsack Problem as the following MINLP: (PHD-KP ) 2 Notice that, if α ≤ 0, the empty solution y = 0 is optimal, as it achieves a value of α 0 = ∞. An illustration of the objective function of the (PHD-KP ) is given in Fig. 4. The following proposition characterizes the computational complexity of the problem.

Proposition 3 An optimal solution to the (PHD-KP ) can be computed in O(n 2 c) and the problem is weakly N P-hard.
Proof The statement follows by observing that the (MD-SP) reduces to the (PHD-KP ). Specifically, by setting p j = q j for all j ∈ N , α = Ψ , c = Φ, and = 2, and by observing that j∈N y j > 0, it holds that, if the optimal solution value of the (PHD-KP ) is strictly positive, then the value d of an optimal solution to the (MD-SP) is strictly positive as well, leading to a violated cover. Alternatively, if the (PHD-KP ) is infeasible, then no cover exists for the (MD-SP). Now, observe that the DP algorithm for the (MD-SP) presented in Sect. 5 can be easily adapted to solve the (PHD-KP ). In particular, by denoting g k n (·) as the function f k n (·) in Sect. 5 in which p replaces q and α replaces Ψ , the (PHD-KP ) can be solved in O(n 2 c). Assuming that the problem is feasible, its optimal solution value is: Otherwise, g k n (c) ≤ 0 for all k ∈ {1, . . . , n − 1} and the problem is infeasible. As for Proposition 2, by storing the values of g k j (s) for all j ∈ N and s ∈ {0, . . . , Φ}, an optimal solution can be reconstructed in linear time by backtracking.
Similarly to the DP algorithm for the (MD-SP), a speed-up technique can be applied also when solving the (PHD-KP ). By computingk as done in Sect. 5 and substituting c for Φ, this leads to a complexity of O(nk c).
Two special cases of the (PHD-KP ) are worth mentioning. First, we note that, if = 1 and if the problem admits a solution containing at least an item, ||y|| = ||y|| ∞ = 1. In such a case, the (PHD-KP ) coincides with the classical KP and, thus, it can be solved in O(n c). We also note that, if = ∞ and α = 0, then ||y|| = ||y|| 1 coincides with the cardinality of the solution. Hence, the optimal solution to the problem can be obtained by selecting a single item of maximum profit, in which case the problem is solved in O(n).
Finally, we note that the solutions to the (PHD-KP ) (i.e., the subsets S) are in general not maximal, especially when p j = 0 for some j ∈ N . In contrast, the solutions to the MD-SP are maximal by construction, even if the instance contains items with q j = 0 for some j ∈ N . This is due to the fact that the denominator of the (PHD-KP ) enforces solutions with a small cardinality, whereas the one of the (MD-SP) enforces solutions with a large cardinality. Thus, even if the (PHD-KP ) can be solved, in principle, for the separation of the cover inequalities, the covers that one would find may not be minimal and, hence, could be dominated.

Experiments when optimizing over the cover-inequality closure
In this section, we investigate the impact of optimizing over the cover-inequality closure by generating maximum-depth cover inequalities within a cutting-plane method where the (MD-SP) is solved to optimality. In line with previous works such as [3,14,15,38], our goal is to assess whether the exact solution of a separation problem based on the cut depth may lead to the generation of a smaller number of cuts, and to quantify how large such a reduction can be. For this reason, we adopt a pure cuttingplane method in which all the separation problems are solved to optimality. As such, the computing times are not our primary concern in the experiment that we are about to present. Moreover, in order to assess the impact of the maximum-depth criterion in a clean setting, we generate a single cut at a time, without resorting to branching, nor to any heuristic separation method. In particular, we remark that assessing the number of cuts generated by heuristic separation methods (which are used in state-of-the-art MILP solvers such as CPLEX, Gurobi, or Xpress; also see the methods proposed in [24]), would be of scarce interest, as such methods do not allow for optimizing exactly over the cover-inequality closure.
We consider two main pure cutting-plane generation methods, MaxD and MaxV. The first one, MaxD, consists in the generation of cover inequalities of maximum depth by solving the (MD-SP) via the DP algorithm we proposed in Sect. 5. We recall that, due to Proposition 1, every cover corresponding to an optimal solution to the (MD-SP) is minimal. The second one, MaxV, is based on the generation of cover inequalities of maximum violation by solving the (MV-SP) via the standard O(n Φ) DP algorithm for the KP described in, e.g., [25,30]. We note that, if some component j ∈ N of the point y being separated is equal to 1 (which leads to a coefficient q j = 0 in the objective function), the solution to the (MV-SP) may not be maximal, which implies that the corresponding cover may not be minimal. In particular, this is the case in most of the algorithm for solving the KP, including [25,30,31], where every item with q j = 0 can be discarded.
For this reason, we also consider a third method, which we refer to as MaxV+, in which, after a cover inequality of maximum violation has been obtained by solving the (MV-SP) via the standard DP algorithm, we turn the corresponding cover into a minimal one with an a posteriori linear-time procedure. From a maximum-depth perspective, we note that the separation algorithm featured in MaxV+ can be interpreted as a heuristic for solving the (MD-SP) (which still allows for optimizing over the closure exactly). Indeed, the separation algorithm in MaxV+ computes, first, a solution which maximizes the cut violation (which corresponds to the numerator of the objective function in the (MD-SP) and, then, it removes items with q j = 0 from the cover to make it minimal. As the items are removed in order of non-increasing weight, this second operation corresponds to minimizing the denominator in the (MD-SP) for a fixed value of the numerator. Overall, this leads to a solution which heuristically maximizes the cut depth.
All the exact separation algorithms that we consider are based on dynamic programming and process the items in a given pre-defined order. To limit the impact of such an order on the tie-breaking choices, in our implementations the items are always taken into account in non-increasing order of weight.
As a case study, we consider two combinatorial problems featuring one or more knapsack constraints: (i) the Knapsack Problem (KP) and (ii) the Multi-dimensional Knapsack Problem (MKP). This family of problems can be cast as the following MILP: where y j is a binary variable equal to 1 if and only if item j ∈ N is chosen, p j is the item profit, and M is a set of m knapsack constraints, with capacities c i (i ∈ M) and item weights w i j (i ∈ M, j ∈ N ). The KP, as well as its numerous variants, has been extensively studied in the literature for over a century [25,30], with works dating as early as 1897 [32]. We refer the reader to [18,[20][21][22]25,30] for more details and the KP and its variants, and to [5,23,24] for works focused on its polyhedral aspects. The MKP is a multi-dimensional extension of the KP featuring m > 1 knapsack constraints. This problem has also been extensively studied in the literature, see e.g., [25,30,36]. In addition, for both problems we also consider the generalization where conflicts between the items are present. Let G = (N , E) be a conflict graph where N is the set of items and E is the set of edges representing the conflicts. To prevent the simultaneous selection of any pair of items i and j with {i, j} ∈ E, the following constraints are imposed: The generalization of the KP to the case with conflicts has been extensively studied in the literature, see, e.g., [9,16,35].
In line with the classes of KP instances proposed in [31], we generate knapsack items, weights, and profits considering the following three classes: uncorrelated, weakly correlated, and subset sum. 3 The instances depend on two user-supplied parameters:c andR. For each knapsack constraint, the capacity c is defined as a percentage of the total item weight W := n j=1 w j , and is set to c := c·W +1.R, which defines the order of magnitude of the item profits and weights, is set to 1,000. We generate 1 or 5 knapsack constraints for each instance, except for those of the subset sum class. For each KP constraint and for each class, we consider n ∈ {20, 40},c ∈ {10%, 20%}. We first generate 200 instances per combination of the parameters. In order to better assess the impact of the different cutting-plane methods, we drop any instance where the total number of cover inequalities generated by MaxV is smaller than 15. We notice that, in spite of this, the number of cover inequalities that are generated never exceeds a couple of hundreds. 4 As far as the conflicts are concerned, thanks to extensive preliminary experiments we noticed that the number of generated cover inequalities decreases when increasing the density of the conflict graph. For this reason, we consider a set of conflict graphs generated by following the Erdös-Rény model with an edge probability of 1%. This way, we obtain a testbed of 2721 KP and MKP instances in which each instance is featured with or without a conflict graph.
The DP algorithms are implemented in C++ and compiled with gcc v9. The results for the three methods MaxD, MaxV, and MaxV+ are summarized in Table 2. Each row groups the results corresponding to n ∈ {20, 40},c ∈ {10%, 20%}, and 200 different seeds, i.e., 800 different instances. The column "conflict" reports the percentage of conflicts, the column "class" reports the class of the instances, the column "# const" reports the number of KP constraints. In the column "# inst", we report the number of instances (out of 800) in which MaxV generates at least 15 cover inequalities inequalities. In each row, the table reports the average and the maximum number of the cover inequalities that are generated to optimize exactly over the cover closure by the corresponding method.
Let us first compare MaxD to MaxV, thus considering the clean setting in which either the cut depth or the cut violation is considered. Our results show that MaxV generates, in total, 103,198 inequalities on the whole testbed (with an average of 37.92 inequalities per instance), whereas MaxD only generates 47,316 (17.38 on average), for a reduction of more than a factor of 2. The maximum difference per instance in the number of generated cuts is 231, and the average one is of 20.54. The Subset Sum instances are the class of instances in which the number of inequalities generated by either algorithm is more substantial (more than twice the number of inequalities that are generated for the instances of the other two classes). The number of instances where MaxV generates at least 15 cover inequalities is substantially larger. We observe that MaxV generates a total of 70,081 inequalities (57.53 on average), in contrast to MaxD, which generates a total of 27,325 inequalities (22.43 on average), for a total reduction of more than a factor of 2.5. As Table 2 shows, the presence of conflict constraints leads to an overall reduction in the number of cover inequalities, which also results in a less When also taking the performance of MaxV+ into consideration, we observe that the latter leads to a very large reduction in the number of cover inequalities w.r.t. MaxV. Interestingly, such a reduction seems to be almost comparable, albeit slightly inferior, to the one obtained with MaxD. Indeed, MaxV+ generates, in total, 50,629 inequalities (18.6 on average), whereas MaxD generates 47,316 inequalities (17.38 on average). As we illustrated before, from a cut-depth perspective such a performance can be explained by interpreting the separation algorithm featured in MaxV+ as a heuristic for solving the separation problem in MaxD. The superior performance of MaxD and MaxV+ confirms that, as can be expected, the impact of generating minimal covers is substantial. Nevertheless, the experiments we carried out on our testbed show that, when maximizing the ratio between the numerator and the denominator of the (MD-SP) exactly, as done in MaxD, it is possible to achieve a further reduction w.r.t. MaxV+ by 7%.
As the separation algorithm embedded in MaxD runs in O(nk Φ), its computing time is larger than the one of the classical DP algorithm used in MaxV, which runs in O(n Φ). While this may be compensated by the reduction in the number of cuttingplane iterations (which also leads to solving a smaller number of LP relaxations), such reduction is, while substantial on the two testbeds we considered, not sufficient to obtain a cutting plane algorithm that is also faster in terms of computing time. Clearly, one of the main driver of the computational time is the number of items n. On average on the 2721 instances we considered, the time taken by MaxD is of ≈ 0.3 s for n = 20 and of ≈ 3.8 s for n = 40. The time taken by MaxV+ is of ≈ 0.02 s for n = 20 and ≈ 0.08 for n = 40. The time taken by MaxV is of ≈ 0.03 s for n = 20 and ≈ 0.16 for n = 40. For MaxD, we have, on average,k 17 for n = 20 andk 36 for n = 40. This shows that, with MaxV+, we obtain not only a reduction in the number of cutting planes, but also in the computing times. The larger computing times of MaxD are in line with the fact that the (MD-SP) solved in MaxD is intrinsically harder than the MV-SP due to being a non-linear variant of the KP with a fractional objective function. We further remark that most of the time is taken by solving the separation problem, and only a fraction of it is spent by reoptimizing the LP after a cut has been added. In a different context where the reoptimization problem that is solved after a cut is added is harder (such as, e.g., a MILP or a very large LP), a reduction in the number of cutting planes could have a beneficial effect on the computing time as well.
In summary, our experiments indicate that, when optimizing over the closure of the cover inequalities, the cut depth is a valid measure whose inclusion can lead to a substantial reduction in the number of cutting planes that are generated. They also reveal that, rather than optimizing such a measure directly, which leads to a harder separation problem, it is better to take it into account indirectly in a heuristic method such as the one featured in MaxV+, whose complexity is the same as that for the standard method in MaxV.

Computational experiments for solving the (PHD-KP )
With this last set of experiments, we focus on the (PHD-KP ), comparing the performance of the DP algorithm we presented in Sect. 6 to BARON v19.12.7, which is one of the state-of-the-art spatial branch-and-bound solvers for global optimization.
Preliminary experiments by running BARON on the formulation (PHD-KP ) reported in Sect. 6 revealed that the solved failed to solve most of the instances, especially for larger values of . This is due to the solver incurring in numerical issues caused by the nature of the numerator, which consists in a high-degree polynomial function. For this reason, the experiments in this section are carried out by using the following formulation: We remark that, by solving this formulation with BARON, one does not have the guarantee that the problem is solved to infinite precision, differently from the case of our DP algorithm. For this reason, to limit as much as possible the impact of adopting a finite precision on the accuracy of the solution to the formulation reported above, we run BARON by setting the optimality tolerance to 0.
For these experiments, we generate the item profits p and weights w as proposed in [31] according to the following 8 different classes: uncorrelated, weakly, Bold indicates the results corresponding to the best algorithm strongly, inverse-strongly, and almost-strongly correlated, subset sum, even-odd subset sum, and even-odd strongly correlated. We consider n ∈ {75, 100, 150}, c ∈ {25%, 50%, 75%}, which determines the knapsack capacity c := c · W + 1, R = 1000, and α := −1. We also consider ∈ {2, 3, 10}, leading us to a total of 216 (PHD-KP ) instances. We adopt a time limit of 600 s for each instance.
The results are reported in Table 3. Each row reports the average computing time in seconds for the instances of the 8 classes generated with the same values of n andc (t[s]) and the number of instances solved to optimality (#opt). The column # reports the number of instances per row. The former is computed by only considering the instances that have been solved to optimality by the associated method.
The table shows that the DP algorithm is able to solve all the 216 instances considered while BARON only solves 180 of them, i.e., ≈ 83%. It also shows that the performance of the DP algorithm is not affected at all by the value of , while the performance of BARON tends to worsen for high values of (see, in particular, the instances with n = 75 andc = 50, 75). The performance of both methods degrades when increasing the number of items, but the impact of n on the performance of the DP algorithm is much smaller than on BARON, showing that the DP algorithm enjoys better scaling properties. In particular, for n = 150 and all the values of andc, BARON always fails to solve two instances. Across the whole testbed, the instances BARON fails to solve are always of the categories even-odd subset sum and even-odd strongly correlated. The table also shows that the knapsack capacity has a negative impact on the performance of the DP algorithm, in line with its pseudopolynomial complexity O(nk c).

Conclusions
This work constitutes a first step on the exact separation of maximum-depth inequalities, focusing on the family of cover inequalities. We have proposed a pseudopolynomial-time Dynamic Programming (DP) algorithm for the maximumdepth separation of such inequalities, which has allowed us to established that the problem is weakly N P-hard. Our experiments have indicated that a maximum-depth approach can lead to a reduction in the number of cuts that are generated when optimizing over the cover-inequality closure using a pure cutting-plane algorithm. Since, however, the computational complexity of the separation problem increases, this has not lead to an overall reduction of the computing times in our experiments. Interestingly, we have observed that a similar reduction in the number of cuts can be obtained via the separation of maximally-violated inequalities whose covers are then made minimal via an a posteriori procedure (which leads to a reduction of the overall computing time).
We have then introduced the Point-to-Hyperplane Distance Knapsack Problem (PHD-KP), which is a variant of the Knapsack Problem with a hyperbolic objective function similar to the one featured in the separation problem of maximum-depth cover inequalities. We have shown how such a problem can be solved to optimality via an extension of the DP algorithm we proposed for the separation problem. For the PHD-KP, our experiments have revealed that our DP algorithm is the most-effective approach when compared to a state-of-the-art spatial branch-and-bound solver in terms of both the computing time and the number of instances solved.
With this letter, we hope to stimulate the research of algorithms for the separation of other families of valid inequalities, such as, e.g., clique constraints or 0-1 2 Gomory cuts [4,27], adopting the maximum-depth criterion. Such a research may also include the adoption of this criterion in the context of Column Generation methods such as those for solving the Set-Partitioning formulation of the Bin Packing Problem, see, e.g., [15,19], by generating columns corresponding to violated dual constraints of maximum depth, whose pricing problem coincides with the PHD-KP.