A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM FOR GENERAL MIXED-INTEGER LINEAR PROGRAMS

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM FOR GENERAL MIXED-INTEGER LINEAR PROGRAMS BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN Abstract. The cutting plane tree (CPT) algorithm provides a finite disjunctive programming procedure to obtain the solution of general mixed-integer linear programs (MILP) with bounded integer variables. In this paper, we present our computational experience with variants of the CPT algorithm. Because the CPT algorithm is based on discovering multi-term disjunctions, this paper is the first to present computational results with multi-term disjunctions. We implement two variants for cut generation using alternative normalization schemes. Our results demonstrate that even a preliminary implementation of the CPT algorithm (with either normalization) is able to close a significant portion of the integrality gap without resorting to branch-and-cut. As a by-product of our experiments, we also conclude that one of the cut generation schemes (namely minimizing the l 1 norm of cut coefficients) appears to have an edge over the other. Key words: Mixed-integer programming, disjunctive programming, cutting planes. 1. Introduction This work constitutes a follow-on to a recent paper (Chen et al., 2009) in which the authors settled several questions related to finite convergence of cutting plane algorithms that use disjunctive cuts for mixed-integer linear programs with general integer variables (MILP-G). The main algorithmic issue that was settled was an answer to the following question: If we are restricted to introducing only one (disjunctive) valid inequality in any iteration, is there a finitely convergent pure cutting plane algorithm that solves MILP-G? The main construct developed to answer this question affirmatively is the notion of a cutting plane tree (CPT). The CPT represents an adaptive sequence of disjunctions involving multiple variables, and is able to discover the convex hull (closure) of any instance of a bounded MILP-G, without having to specify an a priori hierarchy. This characterization is a generalization of the sequential convexification process of Balas (1979) for MILP with binary variables (MILP-B). However, it is important to note that the same sequential process of convexification (one variable at a time) does not yield the convex hull of MILP-G in finitely many steps (Owen and Mehrotra, 2001). Prior to this, Date: September 14, 2010. Binyuan Chen: Department of Systems and Industrial Engineering, University of Arizona, Tucson, AZ 85721, USA. bychen@email.arizona.edu. Simge Küçükyavuz: Department of Integrated Systems Engineering, The Ohio State University, Columbus, OH 43210, USA. kucukyavuz.2@osu.edu. Supported, in part, by NSF-CMMI Grant 0917952. Suvrajeet Sen: (corresponding author) Department of Integrated Systems Engineering, The Ohio State University, Columbus, OH 43210, USA. sen.22@osu.edu. Supported, in part, AFOSR grant FA9550-08-1-0117. 1

2 BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN Cook et al. (1990) showed non-convergence for MILP-G using split disjunctions, and even in the case of MILP-B, Sen and Sherali (1985) presented examples of non-convergence in which facet inequalities of two-term (simple) disjunctions are derived to cut away the solution to the most recent LP relaxation. Chen et al. (2009) use the CPT algorithm to solve the above instances in finitely many iterations. In this sense, the CPT algorithm has the algorithmic power to discern important disjunctions during the course of a cutting plane scheme. In the current paper, we pursue the next logical question: does the algorithmic power of CPT translate into superior computational performance? Since our goal is to investigate the effectiveness of CPT, we will focus on a pure cutting plane algorithm (i.e., no branch-and-cut). Given that there is no computational experience with multi-term disjunctions, this study also provides the first glimpse at the computational potential of using multi-term disjunctions. The only study that we are aware of is the paper by Perregaard and Balas (2001) in which they studied the computational time required to solve a cut generation LP (CGLP) with 2 k -term disjunctions representing all possible combinations of k 0-1 variables. They report computational experience with alternative values of k = 1,..., 4, and alternative solution algorithms for CGLP. However, their study was not intended to investigate the performance of multi-term disjunctions for solving MILP-G. Despite the recent explosion of computational experiments using disjunctive programming (Balas and Bonami, 2009, Balas and Saxena, 2008, Bonami and Minoux, 2005, Fischetti et al., 2009), there is a clear paucity of computational experience with multi-term disjunctions to solve MILPs, let alone, flexible disjunctions of the type generated by the CPT algorithm. In this paper, we investigate whether the cuts generated by the CPT algorithm have the power to close a significant portion of the optimality gap between the LP relaxation and the MILP optimum. Although environments like CPLEX and COIN-OR allow the use of a variety of other cuts, we will switch off all such options, thus testing only the CPT algorithm as a pure cutting plane algorithm. Thus, the current paper is embarking on a preliminary exploration of computations with the CPT process, which if promising, will provide the impetus for more streamlined computational software in the future. Our computational results show that a CPT algorithm can make significant progress towards closing the integrality gap for moderately large MILP instances from MIPLIB 3.0. These results are obtained using two variants, and for each of these, we report that the average gap closure is significant (54% and 61% respectively) within an hour of computing. This paper begins with a brief presentation of the CPT algorithm in Section 2. Following this background, Section 3 provides a discussion of the computer implementation, the experimental setting, and the computational results. In Section 4, we examine these results in connection with those that have appeared in the literature and based on this assessment, we recommend future research directions. 2. Cutting Plane Tree Algorithm Consider a mixed-integer linear program stated as min x X {c x X = {Ax b, x Z n 1 + Rn n 1 + }},

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM 3 where the first n 1 components of x are required to be integers. The set obtained by relaxing the integrality requirements of X is denoted by X L. Let all integer variables be bounded with x j [0, u j ] for all j = 1,..., n 1, where u j could be. Assuming that u j < for all j = 1,..., n 1, Chen et al. (2009) showed that the CPT algorithm is finitely convergent for a version that introduced one disjunctive cut in any iteration. Our computational experiments are carried out with a slight generalization in which multiple cuts are generated using those variables that are fractional in any iteration. This approach, which results in a round of cuts has become standard for computational experiments with lift-and-project cuts (Balas et al., 1996, Bonami and Minoux, 2005) as well as Gomory cuts with multiple source rows. In the cutting plane tree (CPT), T, there is a single root node o. For each node σ T, an integer m σ keeps track of the cutting planes that will be used to generate a disjunctive cut when this node is revisited, an integer v σ {1, 2,..., n 1 } stores the index of the integer variable that is split, and an integer q σ stores the (lower) level of the splitting. Let l σ, r σ and p σ denote links to the left child, right child and parent nodes of node σ, respectively. Let S(σ) be all nodes on the subtree rooted at node σ (not including node σ). Let N (σ) be the collection of the nodes on the path from the root node to node σ (not including the root node), let N (σ) be the collection of each node in N (σ) that is the left child node of its parent and let N + (σ) be the collection of each node in N (σ) that is the right child node of its parent. Given σ T define C σ = {x x j [0, u j ], j = 1,..., n 1, x vps q ps, s N (σ), x vps q ps + 1, s N + (σ)}. Let L k+1 denote the collection of all leaf nodes of the cutting plane tree at iteration k. Let L(t) be the set of leaf nodes on subtree rooted at node t. Let φ k be the number of disjunctive cuts generated until iteration k, hence the number of disjunctive cuts generated in iteration k is φ k+1 φ k. We let m σ store an iteration index, which gives the set X mσ to be used in the cut generation linear program (CGLP) (Balas, 1979, Sherali and Shetty, 1980). The set X k corresponds to X L together with the first φ k cuts added to it. If X k C lσ = (X k C rσ = ), we say that the left (right) child node of σ is fathomed, i.e., l σ = null (r σ = null). The pseudo-code of the cutting plane tree algorithm with rounds of cuts is given in Algorithm 1. At iteration k, if the current extreme point solution to min x Xk c x, given by x k is integral, then we have found the optimal solution to MILP-G. Otherwise, we search the cutting plane tree, to find the last node σ on the path from the root node such that x k C σ. There are two cases: Case (1) σ is a leaf node (σ L k ), Case (2) σ is not a leaf node (σ L k, x k C σ, x k C lσ and x k C rσ ). In Case (1), for each fractional variable x j, let the split variable be v σ = j. We create two new nodes: left (l σ ) and right (r σ ) children of σ at the split level q σ = x k j. We let C j l σ = {x C σ x j x k j } and Cj r σ = {x C σ x j x k j } and create an updated list of leaf nodes, L j k+1 that includes Cj l σ (Cr j σ ), unless C j l σ X k = (Cr j σ X k = ). In this case, we also let m σ = k, as this is the first time the tree search for a fractional solution stops at node σ. In Case (2), the cutting plane tree and m σ are unchanged. However, in this case, we update m t = k for all successors of σ, t S(σ). We generate a valid inequality for the set clconv{ t L j (X mσ C j t )} k+1 that cuts off x k (using CGLP). We describe the CGLP in greater detail in Section 2.1. The new

4 BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN valid inequalities generated for each fractional x j, j {1,..., n 1 } are included along with those defining X k, and the resulting set is denoted by X k+1. This process continues until the stopping criterion is satisfied. Comparing the pseudo-code presented in Algorithm 1 with that presented in Chen et al. (2009), the differences are due to the implementation of the rounds of cuts in line 18 and lines 5 12. The for loop in line 18 lets us generate multiple cuts. Lines 5 12 perform a specific tree management rule, which creates two new nodes in the CPT emanating from the current node σ, provided that one of the fractional variables x j that was used to form a disjunction in the previous iteration (k 1) is integral in iteration k. The split level is q σ = x k 1 j. In effect, the expansion of the tree is delayed until one round of cuts renders a fractional variable integral. Algorithm 1 Cutting plane tree algorithm 1: Initialization: k = 1, create a node o, where p o = null, m o = 1, φ k = 0. Let T = {o}, L k := {o} and C o = {x x j [0, u j ], j = 1,..., n 1 }. Also let X k = X L C o and x k arg min x Xk c T x, where x k is a vertex of X k. 2: while X k and x k j Z for some j {1,..., n 1} do 3: Search for node σ T such that: either σ L k and x k C σ ; or, node σ L k and x k C σ, x k C lσ and x k C rσ. 4: if σ L k then 5: if j = 1,..., n 1 with x k 1 j Z and x k j Z then 6: Let v σ = j, m σ = k, L k+1 L k \ {σ}. 7: Form disjunction(x k, T, L k+1, σ, j, x k 1 ). 8: if x k j q σ then 9: σ l σ. 10: else 11: σ r σ. 12: end if 13: end if 14: else if σ L k and x k C σ, x k C lσ and x k C rσ then 15: Let L k+1 L k, let m t k, t S(σ). 16: end if 17: φ k+1 = φ k, X k+1 X k. 18: for all j = 1,..., n 1 such that x k j Z do 19: Let σ j σ, v σj = j, q σj = x k j, T j T, L k j L k+1, L j k+1 Lj k \ L(σ j). 20: Form disjunction(x k, T j, L j k+1, σ j, j, x k ). 21: Generate a valid inequality for the set clconv{ t L j (X mσ C t )} that cuts off x k (using k+1 CGLP). Append this valid inequality to the set X k+1. Increment φ k+1. 22: end for 23: Let k k + 1. Let x k arg min x Xk c x, where x k is a vertex of X k. 24: end while

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM 5 Algorithm 2 function: Form disjunction (X, T, L, σ, j, x) 1: Create a node l with l σ = l, p l = σ and a node l + with r σ = l +, p l + = σ. 2: Let C l = {x C σ x j x j } and C l + = {x C σ x j x j }. 3: if C l X then 4: Let L L {l }. Let T T {l }. 5: else 6: Let l = null (fathom). 7: end if 8: if C l + X then 9: Let L L {l + }. Let T T {l + }. 10: else 11: Let l + = null (fathom). 12: end if 2.1. Cut Generation. Let x k C σ be the fractional solution at iteration k. For fractional variable x k j, j {1,..., n 1}, define the sets X m C j t = {x A mx b m, L t x U t } for t L j k+1, where A m, b m are the cut-enhanced matrix and right-hand-side vector of MILP-G, with m = m σ. Let the multipliers used in the CGLP be {λ t, µ t, ν t } t L j, where λ t corresponds to the vector of k+1 multipliers associated with A m x b m, and µ t, ν t denote the vectors of multipliers for the lower and upper bound constraints, L t x U t, respectively. The CGLP has the form: (1) (2) (3) (4) max π 0 π x k s.t. π = λ t A m + µ t ν t t L j k+1 π 0 λ t b m + µ t L t νt U t t L j k+1 (λ, µ, ν) 0. The optimal solution to the CGLP yields an inequality π x π 0 valid for X that cuts off x k. The feasible set defined by (2) (4) is a cone, and its extreme rays correspond to valid inequalities including all facets of the disjunctive program at hand. To truncate the feasible set and obtain a bounded solution, various normalization constraints have been studied in the literature (Balas, 1979, Balas and Bonami, 2009, Balas and Perregaard, 2002, Cadoux, 2010, Cornuéjols and Lemaréchal, 2006, Fischetti et al., 2009, Rey and Sagastizábal, 2002). The introduction of the normalization constraint may generate extreme points of CGLP that do not correspond to facets of the convex hull (closure) of the disjunctive set. The computational results presented in Balas et al. (1996), Fischetti et al. (2009), Balas and Bonami (2009), as well as the results summarized in Section 3, show that the choice of normalization has some impact on the performance and stability of the algorithm. Recognizing this, we experiment with two alternatives, although others are clearly possible (Balas and Bonami, 2009, Fischetti et al., 2009). (1) Weighted Cut Coefficients (WCC). This normalization constraint is a variant of that of Balas and Perregaard (2002), with w π = 1, where w = ˆx x k, and ˆx is some feasible solution to clconv{ t L j (X mσ C j t )}. In contrast to this choice of ˆx, Bonami and k+1

6 BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN Minoux (2005) use a mixed-integer feasible solution to X. Since the latter would require our experiments to use either a pre-processing function, or a branch-and-cut algorithm, we modified the recommendation of Balas and Perregaard (2002) to one that fits more naturally in the CPT algorithm. In our implementation, we choose ˆx to be an optimal extreme point of either X k C j l σ or X k Cr j σ, whichever gives a better bound. As shown in Balas and Perregaard (2002), including the constraint w π = 1 to (1) (4) renders the CGLP objective bounded. (2) Minimum 1-Norm Cut (M1NC) Another way to ensure that the CGLP is bounded is to translate the coordinates to the point x k, and then to find a minimum norm hyperplane that separates the origin from the closure of the convex hull of the disjunctive set. As a result, such cuts may be referred to as deep cuts (Cornuéjols and Lemaréchal, 2006, Cadoux, 2010, Rey and Sagastizábal, 2002). As one can recognize, this idea can be traced back to the very origins of optimization, i.e., separating hyperplane theorems. However, care must be taken to implement such ideas in a computationally effective way. It turns out that the choice of the norm used in defining the projection is critical to the success of a computer implementation of the CGLP. Computational experiments reported in Cadoux (2010) suggest that cuts which minimize the l 2 norm do not lead to an effective computational approach. We have confirmed this conclusion in our own experiments. One of the normalizations that we report in Section 3 is based on choosing cut coefficients that minimize the l 1 norm. The resulting CGLP in the translated space, at iteration k for fractional variable x k j, j {1,..., n 1}, is (5) (6) (7) (8) min n j=1 π j s.t. π = λ t A m + µ t ν t t L j k+1 λ t b k m + µ t L k t νt Ut k 1 t L j k+1 (λ, µ, ν) 0 where b k m = b m A m x k, L k t = L t x k and U k t = U t x k. The cut that we obtain is π (x x k ) 1. For the sake of completeness, Appendix A presents the duality between the projection of the origin on to the convex hull (closure) of a disjunctive set using the l norm, and a cut with minimum l 1 norm. 3. Computations with the Cutting Plane Tree Algorithm In this section, we present the first computational study with the CPT algorithm. Since this algorithm creates multi-term disjunctions on-the-fly, it also constitutes the first experiment involving multi-term disjunctions for MILP-G. Our results show that even a preliminary implementation of the CPT algorithm is able to obtain significant reduction in the integrality gap in many of the mixed-integer instances in MIPLIB. As the cutting plane tree algorithm is developed for MILP-G, we tested it on mixed-integer instances in MIPLIB 3.0 (Bixby et al., 1996) that have less than 1000 variables (as in Bonami and Minoux (2005)). In addition, we exclude the

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM 7 Table 1. CPT - alternative normalizations. WCC M1NC Problem n # Z # B time cuts N T % gapcl time cuts N T % gapcl egout 141 0 55 34 269 3 2 100.0 3 136 3 2 100.0 set1ch 712 0 240 3662 1110 4 2 99.2 3602 1386 14 7 99.9 pp08a 240 0 64 3615 815 3 2 97.4 3601 1576 3 2 99.3 dcmulti 548 0 75 3622 522 3 2 94.3 3643 557 8 4 84.3 bell5 104 28 30 3612 204 9 4 92.6 3768 1916 8 3 97.4 pp08acuts 240 0 64 3628 633 3 2 88.6 3607 1252 5 2 97.9 gen 870 6 144 3623 356 5 2 83.3 3609 1084 3 2 90.6 vpm1 378 0 168 3656 887 3 2 76.9 3601 2027 3 2 99.0 vpm2 378 0 168 3600 586 3 2 76.2 3601 1390 3 2 86.4 modglob 422 0 98 3642 350 3 2 71.9 3631 624 5 3 99.5 bell3a 133 32 39 443 97 11 6 70.7 4909 473 15 8 73.2 fixnet6 878 0 378 3603 509 3 2 65.8 3638 558 7 4 84.7 rgn 180 0 100 3602 990 3 2 40.0 3601 1623 7 4 55.6 blend2 353 33 231 3603 552 3 2 33.3 3601 1754 3 2 41.4 qiu 840 0 48 3602 67 1 1 27.8 3614 383 3 2 67.9 flugpl 18 11 0 346 1081 6 3 22.6 3600 4379 8 4 27.9 mas76 151 0 150 1587 31 3 2 22.3 3616 265 7 4 34.0 rout 556 15 300 3617 322 3 2 16.3 3602 801 5 3 4.5 danoint 521 0 56 3773 165 3 2 2.4 3616 195 5 3 1.7 markshare1 62 0 50 3611 397 20 10 0.0 3614 820 45 23 0.0 markshare2 74 0 60 3638 687 13 7 0.0 3603 874 25 13 0.0 pk1 86 0 55 3730 425 9 5 0.0 3603 1763 11 6 0.0 instance noswot which does not have an integrality gap and the instance mas74 which results in numerical difficulties. In Table 1, we report our computational experiments using CPT with multiple cuts per iteration (one for each fractional variable). We compare the two normalization variants (WCC and M1NC) as described in Section 2.1. For each instance, we report the total number of variables (n), the number of general integer variables (#Z) and the number of 0-1 variables (#B). In addition, for each normalization, we report the solution time (in seconds), the number of cuts added, the total number of CPT nodes (N), the number of leaf nodes (disjunctions) in CPT at termination (T ), and the percentage gap closed, respectively. The asterisk in some entries under the WCC normalization indicate numerical difficulties that cause early termination. All computations are done on a 3.2 GHz Sun workstation with 4 GB RAM, under 3600 CPU seconds time limit. Because the implementation delegates cut generation to the LP solver, we are not able to enforce the time limit very strictly during cut generation. In all but one instance (bell3a), the run time is at most a few minutes over the time limit. It is quite remarkable that for several of these instances, both implementations of CPT are able to close more than 90% of the integrality gap with a pure cutting plane approach (especially

8 BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN for bell5 which contains general integer variables). Overall, the average percentage gap improvements are 53.7% and 61.2%, for the WCC and M1NC normalizations, respectively. For over 20% of the test instances (highlighted in bold), there is over 15% increase in the gap improvement using the M1NC normalization compared with the WCC normalization. In particular, for qiu the M1NC normalization provides an additional 40% gap improvement within the same time limit. On the other hand, for instances dcmulti and rout, the WCC normalization provides about 10% gap improvement over the M1NC normalization. We also observe that markshare1, markshare2 and pk1 are hard instances for which Bonami and Minoux (2005), Balas and Saxena (2008), Balas and Bonami (2009) and Fischetti et al. (2009) also report 0% gap closure. If these instances are excluded, the average percentage gap improvements rise to 62.2% and 70.8%, for the WCC and M1NC normalizations, respectively. It should be noted that, M1NC is relatively stable, presenting numerical instability in only one of the instances, namely mas74 (not reported). Based on the above criteria (average gap closure within an hour of computing, and numerical stability), M1NC is clearly the normalization of choice. Table 1 also demonstrates that for moderately sized instances (e.g., less than 1000 variables), the number of disjunctions explored in the CPT is far less than the worst case (full expansion of integer variables), and for such instances, ordinary LP solvers may suffice for cut generation. Moreover, the guidance provided by the objective function and intermediate fractional solutions help limit the number of leaf nodes explored by the CPT algorithm, and does not come close to its worst case bound. 4. Connections with the Literature and Conclusions Over the past 15 years, computations using disjunctive cuts (Balas, 1979) have appeared in a variety of contexts. The first successful implementation of a special case of disjunctive cuts for 0-1 MILP within a branch-and-cut framework, known as the lift-and-project cuts (Balas et al., 1993), is described in Balas et al. (1996). Lift-and-project cuts rely on two-term (simple) disjunctions of the form x k 0 or x k 1, for some binary variable x k. Balas and Perregaard (2002) provide a survey on the recent progress with lift-and-project cuts for 0-1 MILP. In addition, they propose a new normalization constraint for the cut generation linear program (CGLP) of the lift-and-project cuts. Balas and Perregaard (2003) show that lift-and-project cuts from simple disjunctions can be obtained directly from the simplex tableau of the linear programming (LP) relaxation, without solving a larger CGLP. Bonami and Minoux (2005) provide a computational study on the strength of rank-1 lift-and-project cuts and the elementary lift-and-project closure for 0-1 MILP. They conclude that rank-1 lift-and-project cuts are useful in closing a high integrality gap in some instances of MIPLIB 3.0 (Bixby et al., 1996) even when only one round of these cuts is added. The case for MILP with general integers (MILP-G) has not been as well understood, even when the integer variables are bounded. While pure integer programming can be shown to have a finite representation using Gomory cuts (Gomory, 1963), the same is not true for MILP- G, unless the optimal objective function value is known to be integral. Adams and Sherali (2005) provided a generalization of the RLT methodology to the case of MILP-G problems

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM 9 using Lagrange Interpolation Polynomials to compute the bound factors in the RLT process. To the best of our knowledge, there are no computational experiments with this method. For MILP-G, Balas and Saxena (2008) report computational experiments on optimizing over the elementary split closure. Split cuts are obtained from disjunctions that are more general than the simple variable disjunctions, namely α x 1 β or α x 1 β+1, where (α, β) Z n1+1 and x 1 is the vector of integer variables. Despite the generality of the split disjunction, Cook et al. (1990) provide an example to show that the split rank of a MILP-G could be infinite. Furthermore, the separation of split cuts is shown to be N P-hard (Caprara and Letchford, 2003). In their computational study, Balas and Saxena (2008) solve a parametric integer program to generate a violated split cut. While the rank-1 split cuts seem to close a high percentage (about 72%) on average, the computational effort required for their separation is excessive (several hours/days) for most of the test instances. Finally, Zanette et al. (2008) implement Gomory s fractional cutting plane algorithm (Gomory, 1963), which is finitely convergent for MILP-Gs when the optimal objective function value is integral. They test the method on pure ILPs from MIPLIB instances and report that an average of about 40% gap can be closed on these instances within an hour time limit. Compared with previous computational results with cutting plane methods for MILP-G, the gap closure due to the multi-term disjunctive cuts provided by the CPT algorithm is significant (60% within an hour). The bottleneck however, is the solution of CGLP in the extended space. Although the number of disjunctions used for cut generation (T ) is moderate in all instances of Table 1, the overall solution time exceeds one hour. More research is necessary to develop methods to solve large-scale CGLPs arising from multi-term disjunctions effectively. The method proposed in Perregaard and Balas (2001), Balas and Bonami (2009) to solve the CGLP in the original space of the variables works specifically for the case of simple variable disjunctions. In contrast to the CPT, which discovers the multi-term disjunction to be used, Perregaard and Balas (2001) investigate cut generation for a fixed number of terms in a multi-term disjunction. They provide computational results which suggest that Benders decomposition algorithm is faster in generating a fixed number of cuts than solving a large-scale CGLP when there are more than two disjunctions in a CGLP. Nevertheless, the experiments reported in Perregaard and Balas (2001) were not intended to test the effectiveness of multi-term disjunctions in solving MILP-G instances. In this sense, our results are unique for pure cutting plane methods using multi-term disjunctions. Finally, the proposed cutting plane method would work best in a branch-and-cut framework. We are currently exploring these research questions. References Adams, W. P. and Sherali, H. D. (2005). A hierarchy of relaxations leading to the convex hull representation for general discrete optimization problems. Annals of Operations Research, 140(1):21 47. Balas, E. (1979). Disjunctive programming. Annals of Discrete Mathematics, 5:3 51. Balas, E. and Bonami, P. (2009). Generating lift-and-project cuts from the LP simplex tableau: open source implementation and testing of new variants. Mathematical Programming Computation, 1:165 199.

10 BINYUAN CHEN, SİMGE KÜÇÜKYAVUZ, AND SUVRAJEET SEN Balas, E., Ceria, S., and Cornuéjols, G. (1993). A lift-and-project cutting plane algorithm for mixed 0-1 programs. Mathematical Programming, 58:295 324. Balas, E., Ceria, S., and Cornuéjols, G. (1996). Mixed 0-1 programming by lift-and-project in a branch-and-cut framework. Management Science, 42(9):1229 1246. Balas, E. and Perregaard, M. (2002). Lift-and-project for mixed 0-1 programming: recent progress. Discrete Applied Mathematics, 123:129 154. Balas, E. and Perregaard, M. (2003). A precise correspondence between lift-and-project cuts, simple disjunctive cuts, and mixed integer Gomory cuts for 0-1 programming. Mathematical Programming, 94:221 245. Balas, E. and Saxena, A. (2008). Optimizing over the split closure. Mathematical Programming, 113:219 240. Bixby, R. E., Ceria, S., McZeal, C. M., and Savelsbergh, M. W. P. (1996). An updated mixed integer linear programming library: MIPLIB 3.0. http://www.caam.rice.edu/ bixby/miplib/miplib.html. Bonami, P. and Minoux, M. (2005). Using rank-1 lift-and-project closures to generate cuts for 0-1 MIPs, a computational investigation. Discrete Optimization, 2:288 307. Cadoux, F. (2010). Computing deep facet-defining cuts for mixed-integer programming. Mathematical Programming, 122:197 223. Caprara, A. and Letchford, A. (2003). On the separation of split cuts and related inequalities. Mathematical Programming, 94:279 294. Chen, B., Küçükyavuz, S., and Sen, S. (2009). Finite disjunctive programming characterizations for general mixed-integer linear programs. Optimization Online, http://www.optimization-online.org/db HTML/2009/08/2382.html, forthcoming in Operations Research. Cook, W., Kannan, R., and Schrijver, A. (1990). Chvátal closures for mixed integer programming problems. Mathematical Programming, 47:155 174. Cornuéjols, G. and Lemaréchal, C. (2006). A convex-analysis perspective on disjunctive cuts. Mathematical Programming, 106:567 586. Fischetti, M., Lodi, A., and Tramontani, A. (2009). On the separation of disjunctive cuts. forthcoming in Mathematical Programming. Gomory, R. E. (1963). An algorithm for integer solutions to linear programs. In Graves, P. and Wolfe, P., editors, Recent Advances in Mathematical Programming, pages 269 302. McGraw- Hill, New York. Owen, J. H. and Mehrotra, S. (2001). A disjunctive cutting plane procedure for general mixedinteger linear programs. Mathematical Programming, 89:437 448. Perregaard, M. and Balas, E. (2001). Generating cuts from multiple-term disjunctions. In Proceedings of the 8th International IPCO Conference on Integer Programming and Combinatorial Optimization, pages 348 360, London, UK. Springer-Verlag. Rey, P. A. and Sagastizábal, C. A. (2002). Convex normalizations in lift-and-project methods for 0-1 programming. Annals of Operations Research, 116:91 112. Sen, S. and Sherali, H. D. (1985). On the convergence of cutting plane algorithms for a class of nonconvex mathematical programs. Mathematical Programming, 31:42 56.

A COMPUTATIONAL STUDY OF THE CUTTING PLANE TREE ALGORITHM 11 Sherali, H. D. and Shetty, C. M. (1980). Optimization with Disjunctive Constraints. Springer Verlag, Berlin. Zanette, A., Fischetti, M., and Balas, E. (2008). Can pure cutting plane algorithms work? In Proceedings of IPCO 2008, pages 416 434, London, UK. Springer-Verlag. Appendix A. The minimum l 1 norm CGLP For a fractional variable x k j, j {1,..., n 1}, consider the CGLP (in the translated space) that maximizes the violation, subject to an upper bound constraint on the l 1 norm of the cut coefficients: (9) (10) (11) (12) (13) (14) (15) max π 0 π 0 s.t. π = λ t A m + µ t ν t t L j k+1 π 0 λ t b k m µ t L k t + νt Ut k 0 t L j k+1 n i=1 α i = 1 π α π α (λ, µ, ν, α) 0. Because of the positive homogeneity of the the cut generation (set valued) mapping (Cornuéjols and Lemaréchal, 2006, Cadoux, 2010), this CGLP gives a cut π (x x k ) π 0, which is an optimum to M1NC up to a positive scalar multiple. Let y, z, η, y +, y be the dual multipliers of the constraints (10) (14) in that order. Then the dual problem is: min η s.t. η y + i y i 0 i = 1,..., n y + y t L j y t = 0 k+1 A m y t b k mz t 0 t L j k+1 y t L k t z t 0 t L j k+1 y t + Ut k z t 0 t L j k+1 z t = 1 t L j k+1 (y +, y, z) 0. This is the problem of projecting the origin on to the disjunctive set under the l norm, and hence the resulting cut is the deepest cut as measured by the l norm.