arXiv:1010.5412v2 [cs.RO] 27 Oct 2010  On optimizing over lift-and-project closures  Pierre Bonami ∗  Laboratoire d’Informatique Fondamentale, CNRS/Aix Marseille Universit ́ e, Marseille, France  September 23, 2018  Abstract  The lift-and-project closure is the relaxation obtained by computing all lift-and-project cuts from the initial formulation of a mixed integer linear pro- gram or equivalently by computing all mixed integer Gomory cuts read from all tableau’s corresponding to feasible and infeasible bases. In this paper, we present an algorithm for approximating the value of the lift-and-project clo- sure.   The originality of our method is that it is based on a very simple cut generation linear programming problem which is obtained from the original linear relaxation by simply modifying the bounds on the variables and con- straints. This separation LP can also be seen as the dual of the cut generation LP used in disjunctive programming procedures with a particular normaliza- tion. We study some properties of this separation LP in particular relating it to the equivalence between lift-and-project cuts and Gomory cuts shown by Balas and Perregaard.   Finally, we present some computational experiments and comparisons with recent related works.  1   Introduction  In this paper, we consider Mixed Integer Linear Programs (MILP) of the form: max   c ′ T   x s.t. A ′ x   ≥   b, x   ∈   Z p  +   ×   R n − p  +   ,  (MILP)  ∗ Supported by ANR grant ANR06-BLAN-0375  1
where   A ′   is an   m   ×   n   rational matrix,   c ′   ∈   Q n   and   b   ∈   Q m . In the last 20 years, cutting plane methods have become one of the main ingre- dients for solving MILP. State of the art solvers are branch-and-cut algorithms that employ a number of different cutting plane algorithms to automatically strengthen formulations: Gomory Mixed Integer (GMI) Cuts [34], Mixed Integer Rounding cuts [38], Knapsack Covers [14], Flow-covers [39, 40].   The positive impact of these dif- ferent methods on the solution algorithms for MILP have been evaluated in many independent computational studies for example [16]. A central concept in cutting planes for MILP is that of elementary closures. Sim- ply put, the elementary closure of a given family of cuts is the relaxation obtained by applying all cuts of the said family that can be obtained using the initial formulation of MILP only (without a recursive application).   Two well known closures are the Chv ́ atal-Gomory closure [21] obtained by applying all possible Gomory Fractional cuts [33] and the split closure [22]. Elementary closure have been a fruitful concept from a theoretical standpoint. In particular, four important results are the facts that the Chv ́ atal-Gomory closure is a polyhedron [21] on which it is NP-hard to optimize [27] and that the split closure is also a polyhedron [22] on which it is NP-Hard to op- timize [20]. More recently, closures have also been considered from a computational point of view. Several authors have computed empirically the strength of different closures on problem instances from the literature: Fischetti and Lodi have computed the Chv ́ atal-Gomory closure [28], Bonami and Minoux the lift-and-project closure [19], Bonami et. al. the projected Chv ́ atal-Gomory closure [18], Balas and Saxena the split closure [13] and Dash, G ̈ unluk and Lodi the MIR closure [26]. These studies have shown that elementary closure often give rise to strong relaxation of MILPs. In particular, the Split and MIR closures, which are equivalent, often close a very significant portion of the integrity gap, even though computing time are prohibitive. In that view an interesting line of research is to devise faster algorithms that could give a fairly good approximation of the split closures. In this paper, we are interested in approximating the split closure by looking at simpler (and weaker) closures that are defined by two families of cuts:   GMI cuts read from LP tableau’s and   strengthened lift-and-project cuts   [7].   It was shown by Balas and Perregaard [12] that both classes of cuts are equivalent and define the same closure which we call   lift-and-project closure .   The lift-and-project closure is a polyhedron but, to the best of our knowledge, it is not known whether it can be optimized in polynomial time.   A weaker closure that can be optimized in polyno- mial time is the elementary lift-and-project closure on which one can separate in polynomial time by using disjunctive programming.   Our goal in this paper is to devise efficient algorithms to compute the elementary lift-and-project closure and to 2
approximate heuristically the lift-and-project closure. Our approach is similar to the one proposed in [19]: we optimize the elementary lift-and-project closure by a cutting plane algorithm and strengthen each cut indi- vidually to approximate the lift-and-project closure.   Our main contribution with respect to [19] is that we use a different cut generation oracle. While in [19] a linear program in an extended space is solved to generate each cut, here we solve a linear program in the original space of variables which we call   membership LP . Further- more, we are able to establish some nice properties of this membership LP, and show that it is typically solved in very few iterations. Our work is related to [12].   First the membership LP is related to disjunctive programming and the classical Cut Generation LP (CGLP). It can be seen as the dual of a simplified version of the CGLP used in [12]. The simplicity of its structure allows us to give a new view on the equivalence between strengthened lift-and-project cuts and GMI cuts that was shown in [12].   It also gives further insights into this equivalence.   In particular a separation algorithm was proposed in [12] to separate lift-and-project cuts in the LP tableau of the linear relaxation.   One limitation of the algorithm is that it only works by improving an existing cut, our separation procedure removes this limitation. Our work is also related to several recent computational studies. Dash and Goy- coolea [25] and Fischetti and Salvagnin [31] proposed two different methods for sep- arating rank-1 GMI cuts from alternate bases of the LP relaxation. Our work can be seen as a third proposal for finding rank-1 GMI cuts. We also note that the same separation LP that we use, was independently used in a recent work by Fischetti and Salvagnin [30] to also optimize on the simple lift-and-project closure. In Section 2, we give formal definitions of the various cutting planes and closures we are interested in. In section 3, we introduce the membership LP and establish its relations to disjunctive programming. In Section 4, we establish various properties of the solutions of the membership LP and relate it to GMI cuts. In Section 5, we discuss the practical solution of the membership LP and its use for optimizing the lift-and-project closure. Finally, in Section 6, we present computational results. 3
2   Definitions and basic results  The Linear Programming (LP) relaxation of (MILP) obtained by dropping all in- tegrity constraints is max   c ′ T   x s.t. A ′ x   ≥   b, x   ∈   R n  + .  (LP) We also consider the standard form of (LP) where slack variables are introduced: max   c T   x s.t. Ax   =   b, x   ∈   R n + m  +   .  (SLP) In (SLP), we assume that the slack variables are the first   m   ones ( x 1 , . . . , x m ) and the structural variables are the last   n   ( x m +1 , . . . , x m + n ). With this ordering of the variables   A   = ( − I A ′ ) (where   I   is the identity matrix) and   c T   = (0 T   , c ′ T   ).   We denote by   N   :=   { m   + 1 , . . . , m   +   n }   the index set of structural variables in (SLP), by  N I   :=   { m   + 1 , . . . , m   +   p }   the index set of integer constrained structural variables and by   M   :=   { 1 , . . . , m }   the set of slack variables (or the set of constraints). Given a set   J   ⊆   M   ∪   N , we denote by   x J   the vector with component in   J   and by   A J   the sub-matrix of   A   composed by the columns   i   ∈   J   ( A ′   =   A N   ).   Given   J   ⊆   M , we denote by   A J   the sub-matrix of   A   composed by the rows of   A   indexed by   J .   By abuse of notations we will denote   A { j }   and   A { i }   by   A j   and   A i   respectively. We denote the index set of variables in a basis of LP by   B   :=   { i 1 , . . . , i m } ⊆ { 1 , . . . , n   +   m }   and the index set of nonbasic variables by   J   :=   { 1 , . . . , n   +   m } \   B . Given the index set of a basis   B ;   A B   is the basis matrix (we recall that variables in- dexed by   B   form a basis whenever   A B   is non-singular), the LP tableau corresponding to   B   is given by  x B   =   A B   − 1 b   −   A B   − 1 A J   x J   .  Finally, we denote   A   =   A B   − 1 A   and   b   =   A B   − 1 b . Next, we define the four cutting planes used in this paper: simple intersection cut, GMI cut, lift-and-project cut and strengthened lift-and-project cut. 4
2.1   Cutting planes  Before proceeding to the definitions of the various cutting planes, we briefly remind the concepts of disjunctive and split cuts that are central to the four methods. In MILP, we call disjunction a condition of the form   A 1 x   ≥   b 1   ∨   A 2 x   ≥   b 2   ∨   . . .   ∨  A q x   ≥   b q   that is satisfied by all solutions to (MILP) (i.e. each solution of (MILP) verifies at least one of the systems of inequalities). For example, if ( π, π 0 )   ∈   Z n +1   is such that   π { p +1 ,...,n }   = 0 the   split disjunction   π T   x   ≤   π 0   ∨   π T   x   ≥   π 0   + 1 is valid for (MILP). All inequalities presented here, result from split disjunctive in that, for a given ( π, π 0 ) they are valid inequalities for the set:  P   ( π,π 0 )   := conv   ({ x   ∈   R n  +   :   A ′ x   ≥   b, π T   x   ≤   π 0  }   ∪   { x   ∈   R n  +   :   A ′ x   ≥   b, π T   x   ≥   π 0   + 1 })   .  As such, all the inequalities presented belong to the family of   split cuts [22].  The simple intersection cut   Let   B   be a basis of (SLP) and   i k   ∈   B   ∩   N I   be such that   b k   6   ∈   Z . The row of the simplex tableau corresponding to   i k   is  x i k   +   ∑  j ∈ J  a kj   x j   =   b k   (1) Let   f 0   =   b k   − ⌊ b k ⌋ . The   intersection cut   [3] from the convex set   { x   ∈   R n + m   :   ⌊ b k ⌋ ≤  x i k   ≤ ⌈ b k ⌉}   applied to (1) is  ∑  j ∈ J  max   { a kj   (1   −   f 0 ) ,   − a kj   f 0 }   x j   ≥   f 0 (1   −   f 0 )   (2) This cut is valid for all solution to (MILP) and is also known as the   simple disjunctive cut   from the condition   x i k   ≤ ⌊ b k ⌋ ∨   x i k   ≥ ⌈ b k ⌉ .  Gomory Mixed Integer Cut   The simple intersection cut can be strengthened using the integrity of the variables in   J   ∩   N I   .   For each   j   ∈   J   ∩   N I   we define  f j   :=   a kj   − ⌊ a kj   ⌋ . We define   π   ∈   Z m + n   as  π j   :=            ⌊ a kj   ⌋   if   j   ∈   J   ∩   N I   and   f j   ≤   f 0 ,  ⌈ a kj   ⌉   if   j   ∈   J   ∩   N I   and   f j   > f 0  1   if   j   =   i k ,  0   otherwise. 5
The Gomory Mixed-Integer Cut is the intersection cut from the convex set   { x   ∈  R n + m   :   ⌊ b k ⌋ ≤   π T   x   ≤ ⌈ b k ⌉}   applied to (1):  ∑  j ∈ J ∩ N   I  f j   ≤ f 0  f j   (1 − f 0 ) x j   +   ∑  j ∈ J ∩ N   I  f j   >f 0  (1 − f j   ) f 0 x j   +   ∑  j ∈ J \ N   I  max   { a kj   (1   −   f 0 ) ,   − a kj   f 0 }   x j   ≥   f 0 (1 − f 0 ) (3) We note that the GMI cut dominates all intersection cuts obtained from row (1) and convex sets of the form   { x   ∈   R n + m   :   ⌊ b k ⌋ ≤   π T   x   ≤ ⌈ b k ⌉}   with   π ( J \ N   I   ) ∪ ( B \{ i k   } )   = 0 and   π i k   = 1 (see [1] for a proof).  The lift-and-project cut   The lift-and-project cuts are the valid inequalities for the sets   P   ( e k ,π 0 )   taken for any   k   = 1 , . . . , p   and   π 0   ∈   Z , obtained by intersecting the polyhedron   { x   ∈   R n  +   :   A ′ x   ≥   b }   with a simple disjunction of the form   x k   ≤   π 0   ∨   x k   ≥  π 0   + 1. The fundamental theorem of Balas [5, 4] on unions of polyhedra allows to formu- late the separation problem for   P   ( e k   ,π 0 )   as a linear program.  Theorem 1   ([5, 7]) .   Let   ˆ x   ∈   R n  + .   ˆ x   ∈   P   ( π,π 0 )   if and only if the solution to the Cut Generation LP  min   α T   ˆ x   −   β s.t.   :  α   =   u T   A N   +   s   −   u 0 π, α   =   v T   A N   +   t   +   v 0 π, β   =   u T   b   −   u 0 π 0 , β   =   v T   b   +   v 0 ( π 0   + 1) , α   ∈   R n , β   ∈   R , u, v   ∈   R m  +   , s, t   ∈   R n  + , u 0 , v 0   ∈   R + ,  is non-negative.  If the solution the cut generation linear program is negative,   α T   x   ≥   β   defines a valid inequality in the space of structural variables that cuts off the point ˆ x . Lift-and-project cuts are separated by solving the cut generation linear program for simple disjunctive (i.e. with   π   =   e k ). Since this program is unbounded whenever it has a negative solution, a   normalization constraint   is often added to cut the cone of feasible solution. Following [11], the most commonly used constraint is   ∑  i ∈ M   ( u i   +  v i ) +   ∑  i ∈ N   ( s i   +   t i ) +   u 0   +   v 0   = 1.   In the remainder, we denote by (CGLP) the cut generation linear program of Theorem 1 augmented with that normalization condition. 6
The strengthened lift-and-project cut   Lift-and-project cuts can be strength- ened in a similar fashion as simple intersection cuts can be strengthened to GMI cuts. Consider a basic solution ( ˆ α,   ˆ β,   ˆ u,   ˆ v,   ˆ s,   ˆ t,   ˆ u 0 ,   ˆ v 0 ) to (CGLP), the coefficients ˆ α   ver- ify: ˆ α k   = max { ˆ uA k   −   ˆ u 0 ,   ˆ vA k   + ˆ v 0 }  and ˆ α j   = max { ˆ uA j   ,   ˆ vA j   } ,   j   6   =   k  These coefficients can be strengthened by replacing ˆ α j   , for   j   ∈ { 1 , . . . , p } \ { k } , with  α j   := min { ˆ uA j   −   ˆ u 0 ⌊ m j   ⌋ ,   ˆ vA j   + ˆ v 0 ⌈ m j   ⌉}  where  m j   := ˆ uA j   −   ˆ vA j  ˆ u 0   + ˆ v 0  ,  (see [10, 8] for justifications.)  2.2   Equivalences and Closures  Balas and Perregaard showed that simple intersection cuts are equivalent to lift-and- project cuts, and that GMI cuts are equivalent to strengthened lift-and-project cuts [12]. The equivalence can be stated as follows: every simple intersection cut (resp. GMI cut) from a basic solution (feasible or not) of (SLP) can be derived as a lift-and- project cut (resp. strengthened lift-and-project cut) obtained from a basic feasible solution of (CGLP); and conversely every lift-and-project cut from a basic feasible solution of (CGLP) is an intersection cut. Here similar means that after the two cuts are put into the same space by eliminating slack variables they are identical up to multiplication by a positive scalar. The equivalence gives the precise correspondence between the two bases of (SLP) and (CGLP). In view of this result, solving (CGLP) can be interpreted as finding a good basis from which to generate a GMI cut. We note that this result is stated in [12] for 0-1 MILP only but its generalization to MILP is straightforward. Generally speaking, the elementary closure of a family of cuts consists of all cuts in the family that can be obtained directly from the initial formulation.   A direct consequence of the result mentioned above is that lift-and-project cuts and simple intersection cuts on one hand and GMI cuts and strengthened lift-and-project cuts on the other hand are equivalent in terms of their closures [23]. 7
The simple lift-and-project closure is obtained by taking all cuts defined by basic feasible solutions to (CGLP). We denote it by   P e . Geometrically, It is obtained by intersecting all polyhedra   P   ( e k   ,π 0 )   for all   k   ∈ { 1 , . . . , p }   and all   π 0   ∈   Z :  P e   :=   ⋂  k ∈{ 1 ,...,p }  π 0 ∈ Z  P   ( e k   ,π 0 )  Equivalently,   P e   is obtained by taking all simple intersection cuts from all bases (feasible and infeasible) of (SLP).   We denote by   B   the set of all bases of (SLP). For each   B   ∈ B , we define   P   ( B ) the cone obtained by dropping the non-negativity requirements of the variables   j   6   ∈   B :  P   ( B ) :=   { x   ∈   R n + m   :   x B   =   b   −   A J   x J   , x J   ≥   0 } .  The simple lift-and-project closure can be defined alternatively as  P e   = proj N  ( ⋂  B ∈B  ⋂  k ∈ N   I   ∩ B  conv   ( P   ( B )   ∩   { x   ∈   R n + m   :   x m + k   ≤ ⌊ b k ⌋ ∨   x m + k   ≤ ⌈ b k ⌉ }))  .  (where proj N   denotes the projection onto the space of structural variables). The lift-and-project closure is defined by taking all strengthened lift-and-project cuts obtained from all basic feasible solutions to (CGLP). We denote it by   P e ∗   . It is more difficult to give a precise and intuitive geometrical definition of it than for  P e . By using the equivalence between lift-and-project cuts and GMI cuts,   P e ∗   is also obtained by taking all GMI cuts defined from all bases of (SLP). More formally, for each basis   B   ∈ B   and   k   ∈   N I   ∩   B , let Π B k   :=   { ( π, π 0 )   ∈   Z n +1   :   π k   = 1 , π N   \ N   I   ∪ B \{ k }   = 0 , π 0   =   ⌊ b k ⌋} .   Π B k   be the subset of splits that are considered for strengthening the simple intersection cut from basis   B   and variable   k   (i.e. all valid splits which have zero coefficients for all basic variables except one). The lift-and-project closure is the intersection of all strengthened intersections cut obtained from these larger subset of splits:  P e ∗   := proj N    ⋂  B ∈B  ⋂  k ∈ N   I   ∩ B  ⋂  ( π,π 0 ) ∈ Π B k  conv   ( P   ( B )   ∩   { x   ∈   R n + m   :   π T   x   ≤   π 0   ∨   π T   x   ≥   π 0   + 1 })     .  Since both   P e   and   P e ∗   are defined by a finite number of inequalities both are clearly polyhedra. Moreover,   P e   can be optimized in polynomial time. To the best of our knowledge, it is not known if   P e ∗   can be optimized in polynomial time. 8
Finally, let us remind that the split closure   P S   is obtained by intersecting all split cuts:  P S   :=   ⋂  ( π,π 0 ) ∈ Z n × Z  π { p +1 ,...,n }   =0  P   ( π,π 0 ) .  As shown by [22],   P S   is a polyhedron. Andersen, Cornu ́ ejols and Li [2] have shown that   P S   can also be defined in terms of intersection cuts:  P S   = proj N      ⋂  B ∈B  ⋂  ( π,π 0 ) ∈ Z n × Z  π { p +1 ,...,n } =0  conv   ( P   ( B )   ∩   { x   ∈   R n + m   :   π T   x   ≤   π 0   ∨   π T   x   ≥   π 0   + 1 })       .  From the definitions, it should be clear that   P S   ⊆   P e ∗   ⊆   P e ∗   , since   P e ∗   and   P e   only use a subset of splits and elementary disjunctions belong to Π B k   . It is NP-Hard to optimize over   P S   .   Computational studies such as [13, 26] have shown that it can be a strong relaxation, but computational times are often prohibitive (in the two studies computing   P S   often takes more time than solving MILP to optimality). This justifies our motivation to optimize   P e ∗   and   P e .  3   The membership LP  In this section, we establish a linear program which given a split disjunction ( π, π 0 ) and a point ˆ x   ∈   R n   answers the question of whether ˆ x   ∈   P   ( π,π 0 ) . It should appear immediately that this question can already be answered by solving (CGLP) using Theorem 1.   Our linear program is indeed similar to (CGLP), by duality, but it does not require the introduction of new variables and is formulated in the same space as (LP). We will mostly use the results of this section in the context of simple disjunctive (i.e. when   π   =   e k ), but since they are not restricted to simple disjunctive, we present them in the more general context of split disjunctive. Our membership LP is based on the following proposition.  Proposition 2.   Let   P   =   { x   ∈   R n  +   :   A ′ x   ≥   b } ,   ˆ x   ∈   P   and   ( π 0 , π )   ∈   Z n +1   be such that  π 0   < π T   ˆ x < π 0   + 1 .   ˆ x   ∈   conv   ( P   ∩   ({ π T   x   ≤   π 0  }   ∪   { π T   x   ≥   π 0   + 1 }))   if and only if there exists   y   ∈   R n   such that  π T   y   −   ( π 0   + 1) ( π ˆ x   −   π 0 )   ≥   0 0   ≤   A ′ y   −   b   ( π ˆ x   −   π 0 )   ≤   A ′   ˆ x   −   b  0   ≤   y   ≤   ˆ x  (4) 9
This proposition can be proved in different ways. In particular, it is closely related to classical results of disjunctive programming.   We will discuss in the following paragraphs the connections between (4) and (CGLP). First, we give a short and self contained proof of it since it provides a simple way to understand (4).  Proof.   (i)   Suppose that ˆ x   ∈   P   ( π 0 ,π ) .   Since   π T   ˆ x   −   π 0   ∈ ]0 ,   1[, there exists   x 0   ∈  P   ∩ { π T   x   ≤   π 0  } ,   x 1   ∈   P   ∩ { π T   x   ≥   π 0   + 1 }   and   λ   ∈ ]0 ,   1[ such that ˆ x   =   λx 1   +(1 −  λ ) x 0 . Without loss of generality, we can assume that   π T   x 0   =   π 0 ,   π T   x 1   =   π 0   +1. Then, since   π T   ( λx 1   + (1   −   λ ) x 0 ) =   π T   ˆ x , we have  λ   =   π T   ˆ x   −   π 0 .  We take   y   =   λx 1   and verify that it satisfies (4). First,   π T   y   −   ( π 0   + 1)( π T   ˆ x   −   π 0 ) =   λ ( π 0   + 1)   −   ( π 0   + 1) λ   = 0. Also,   A y   −   b ( π T   ˆ x   −  π 0 ) = ( Ax 1   −   b )   λ   ≥   0 and   y   =   λx 1   ≥   0, since   Ax 1   ≥   b   ,   x 1   ≥   0 and   λ   ≥   0. Furthermore, since ˆ x   =   y   + (1   −   λ ) x 0   we have:  A y   −   λb   + (1   −   λ )( Ax 0   −   b ) =   A ˆ x   −   b.  and therefore, since   Ax 0   −   b   ≥   0 and   λ   ≤   1  A y   −   λb   ≤   A ˆ x   −   b. y   ≤   ˆ x   in the same manner.  (ii)   Suppose now that   y   satisfies (4).   Let   λ   =   π ˆ x   −   π 0 .   Note that 0   < λ <   1 by hypothesis. We take   x 1   =   y  λ   and   x 0   =   ˆ x − y  1 − λ   . Clearly ˆ x   =   λx 1   + (1   −   λ ) x 0 . Furthermore   x 1   ∈   P   and   π T   x 1   ≥   π 0   + 1. It remains to show that   x 0   ∈   P   ∩ { π T   x   ≤   π 0 } .   x 0   ∈   P   , since (1   −   λ )( Ax 0   −   b ) =  A (ˆ x   −   y )   −   b   +   bλ   =   A ˆ x   −   b   −   A y   +   bλ   ≥   0 and (1   −   λ ) x 0   = ˆ x   −   y   ≥   0. Finally  π T   x 0 − π 0   =   π T   ˆ x   −   π T   y   −   (1   −   λ ) π 0  1   −   λ   =   − π T   y   +   λ   +   λπ 0  1   −   λ   =   − π T   y   −   ( π 0   + 1) λ  1   −   λ   ≤   0  By applying Proposition 2, we can formulate a linear program which answers the question of membership for ˆ x   and   P   ( π 0 ,π ) : max   π T   y   −   ( π 0   + 1) ( π ˆ x   −   π 0 ) s.t.: 0   ≤   A ′ y   −   b   ( π ˆ x   −   π 0 )   ≤   A ′   ˆ x   −   b,  0   ≤   y   ≤   ˆ x.  (MLP) 10
As a direct application of the proposition, ˆ x   ∈   P   ( π 0 ,π )   if and only if the optimal solution to (MLP) is non-negative. An alternative way to prove the theorem is to see that (MLP) is closely related to the dual of (CGLP) with the normalization condition   u 0   +   v 0   = 1: min   α T   ˆ x   −   β  s.t.:  α   =   u T   A ′   +   s   −   u 0 π, α   =   v T   A ′   +   t   +   v 0 π, β   =   u T   b   −   π 0 u 0 , β   =   v T   b   + ( π 0   + 1) v 0 , u 0   +   v 0   = 1 , u, v   ∈   R m  +   , s, t   ∈   R n  + , u 0 , v 0   ∈   R +  (CGLP’) A basic results stated in [12] (Lemma 1) is that in any solution of (CGLP) that yields an inequality   α T   x   ≥   β   that is not dominated by the constraint of (LP), both   u 0   and  v 0   are positive.   The following lemma shows that in fact, if we assume ˆ x   ∈   P   and  π 0   < π T   ˆ x < π 0   + 1, the conditions   u 0 , v 0   ≥   0 can be dropped from (CGLP’).  Lemma 3.   Let   ˆ x   ∈   P   be such that   π 0   < π T   ˆ x < π 0   +1 . Suppose that   ( α, β, u, v, u 0 , v 0 )  verifies the following system of equations:  α   =   u T   A ′   +   s   −   u 0 π, α   =   v T   A ′   +   t   +   v 0 π, β   =   u T   b   −   π 0 u 0 , β   =   v T   b   + ( π 0   + 1) v 0 , u 0   +   v 0   = 1 , u, v   ∈   R m  +   , s, t   ∈   R n  + , u 0 , v 0   ∈   R  with   u 0   ≤   0   or   v 0   ≤   0 . Then   α T   ˆ x   ≥   β . Proof.   The proof if similar for   u 0   ≤   0 and   v 0   ≤   0; we only consider the case   u 0   ≤   0. Let ( α, β, u, v, u 0 , v 0 ) be a vector that satisfies the conditions of the statement. Then, by definition of ( α, β, u, v, u 0 , v 0 )  α T   ˆ x   −   β   = ( u T   A ′   +   s   −   u 0 π )ˆ x   −   u T   b   +   π 0 u 0   =   u T   ( A ′   ˆ x   −   b )   −   u 0 ( π T   ˆ x   −   π 0 ) .  Now the last quantity is non-negative since   u   ≥   0,   A ′   ˆ x   −   b ,   π T   ˆ x > π 0   and   u 0   ≤   0.  11
Since we are only interested in negative solutions to (CGLP’), by application of the lemma, we can therefore remove the conditions   u 0 , v 0   ≥   0. After removing non-negativity constraints on   u 0   and   v 0 , we can eliminate   α ,   β  and   v 0   from (CGLP’): min( u T   A ′ )ˆ x   + ( s   −   u 0 π ) T   ˆ x   −   u T   b   −   π 0 u 0 ,  s.t.: ( u   −   v ) T   A ′   + ( s   −   t ) =   π  ( v   −   u ) T   b   −   u 0   =   − π 0   −   1  u, v   ∈   R m  +   , s, t   ∈   R n  + , u 0   ∈   R  Finally we eliminate   u 0 : min   u T   ( A ˆ x   −   b ) +   s T   ˆ x   + ( π T   ˆ x   −   π 0 )   ( ( u   −   v ) T   b   −   π 0   −   1 )   ,  s.t.: ( u   −   v ) T   A   + ( s   −   t ) =   π u, v   ∈   R m  +   , s, t   ∈   R n  + .  (5) Taking the dual, with multipliers   y   associated to the constraints, one obtains (MLP). It should be clear from this development that a dual feasible solution to (MLP) with negative dual cost gives rise to a valid cut for   P   ( π,π 0 ) .  Remark 4.   Note that one should be careful when dropping the non-negativity con- ditions on   u 0   and   v 0   in   (CGLP’) .   This has indeed one important consequence: while non-negative solutions to   (CGLP’)   define valid (non-violated) inequalities, non- negative solution to   (5)   do not. For example, the trivial solution   u   =   v   = 0 ,   s   − t   =   π  is always feasible for   (5)   but the inequality it defines is not necessarily valid.   For example take   π   =   e k   and   π 0   = 1 , the solution   u   =   v   = 0 ,   t   = 0 ,   s   =   e k   defines the in- equality   x k   ≤   2   which certainly can not be valid for all integer programs! Nevertheless if the solution is negative, it gives a valid cut.  (CGLP’) (with that normalization condition) has been studied previously in [7, 11, 29]. A well known property of the normalization condition   u 0   +   v 0   = 1 is that if ˆ x   is an extreme point of   P   such that 0   <   ˆ x k   −   π 0   <   1 then an optimal solution to (CGLP’) with   π   =   e k   is the intersection cut obtained from a basis defining ˆ x   and the corresponding strengthened cut is the GMI cut from the same basis (see [29] for a precise statement and a complete proof). In the next proposition, we re-state the property in the context of (MLP).   Looking at (MLP), we are able to give a 12
slightly more precise view: if ˆ x   is an extreme point, (MLP) has a unique solution. We present a proof of the results in the context of (MLP) since it is short and gives insights into the connections between (LP) and (MLP) (the fact that the associated cut is the intersection cut will follow directly from the results of the next section, we delay the proof until then).  Proposition 5.   Let   P   =   { x   ∈   R n  +   :   Ax   ≥   b } , and   ˆ x   be an extreme point of   P   such that   0   < π T   ˆ x   −   π 0   <   1 , then the unique solution to  max   π T   y   −   ( π 0   + 1)( π ˆ x   −   π 0 )  s.t.:  0   ≤   A ′ y   −   b ( π ˆ x   −   π 0 )   ≤   A ′   ˆ x   −   b  0   ≤   y   ≤   ˆ x  (6)  is   y   = ˆ x ( π T   ˆ x   −   π 0 ) . Furthermore   π T   y   −   ( π 0   + 1)( π ˆ x   −   π 0 )   <   0 . Proof.   First, we prove that   y   is a solution. Since 0   < π ˆ x   −   π 0   <   1, and   A ˆ x   −   b   ≥   0: 0   ≤   ( π ˆ x   −   π 0 )( A ˆ x   −   b )   ≤   A ˆ x   −   b  and also 0   ≤   ( π ˆ x   −   π 0 )ˆ x   ≤   ˆ x . Second, we show that this solution is unique. We denote by   A = x   =   b = , x =   = 0, the subset of the inequalities defining   P   satisfied at equality by ˆ x .   Since ˆ x   is an extreme point of   P   , it is the unique solution of   A = x   =   b = , x =   = 0. A solution of (6) satisfies:   A = y   −   b = ( π T   x   −   π 0 ) = 0  y =   = 0 .  This system in turn has a unique solution. Finally, it is trivial to check that   π T   y   −   ( π 0   + 1)( π ˆ x   −   π 0 )   <   0:  π T   y   −   ( π 0   + 1)( π ˆ x   −   π 0 ) = ( π ˆ x   −   π 0   −   1)( π ˆ x   −   π 0 ) which is the product of a positive and a negative number and therefore always neg- ative.  This Lemma has important consequences for the practical usefulness of (MLP). In particular, it exposes its main weakness with respect to classical lift-and-project cut generation LPs with more general normalization condition such as the one used in [12]. 13
The standard way to apply lift-and-project cuts (and GMI cuts), is to generate them recursively by rounds where at each round the current basic optimal solution to the LP relaxation (computed by the simplex algorithm) is cut by separating one lift- and-project cut for each basic fractional integer constrained variable. At the end of the round all the lift-and-project cuts generated are added to the LP relaxation and the process is iterated recursively.   In such an algorithm, using (MLP) to generate cuts brings little novelty since the point to cut is always an extreme point of the polyhedron used to separate and the cuts generated would therefore be GMI cuts (and they could certainly be read more quickly from the optimal LP tableau). Nevertheless, there are contexts where solving (MLP) could present a practical interest. In particular one can not always assume that ˆ x   is an extreme point of   P   . This is the case, for example, if the objective function in (MILP) is replaced with a nonlinear convex function, or if the LP relaxation is solved with an interior point method. In this work, we will focus on another case of interest: generating cuts of lowest rank.   If in the procedure outlined above, one does not use the previously generated cuts to generate new cuts, then the point to cut is not an extreme point of the polyhedron used to separate.  4   Correspondences and equivalences  Our goal in this section is to relate the cuts that can be obtained from the solution of (MLP) with intersection and GMI cuts. We consider only elementary disjunctions of the form   x k   ≤   π 0   ∨   x k   ≥   π 0   + 1. Note that this assumption is not restrictive since any split   π T   x   ≤   π 0   ∨   π T   x   ≥   π 0   + 1 can always be put into this form by defining a new variable to be equal to   π T   x . For this elementary disjunction, the membership LP is   max   y k   − ⌈ ˆ x k ⌉ (ˆ x k   − ⌊ ˆ x k   ⌋ ) ,  s.t.: 0   ≤   A ′ y   −   b (ˆ x k   − ⌊ ˆ x k ⌋ )   ≤   A ′   ˆ x   −   b,  0   ≤   y   ≤   ˆ x, y   ∈   R n .  (MLP’ k ) For ease of notation, in the sequel, we denote (ˆ x k   − ⌊ ˆ x k ⌋ ) by   f k . We are interested in dual feasible solutions of (MLP’ k ) since they define cuts for 14
our (MILP). The dual of (MLP’ k ) is the Cut Generation Linear Program min   u T   ( A ′   ˆ x   −   b ) +   s T   ˆ x   + ( u   −   v ) T   bf k   − ⌈ ˆ x k ⌉ f k  s.t.: ( u   −   v ) T   A   + ( s   −   t ) =   e k  u, v   ∈   R m  +   , s, t   ∈   R n  + .  (CGLP’ k ) A solution ( u, v, s, t ) to (CGLP’ k ) defines a cut of the form:  u T   A ′ x   +   s T   x   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  x k   ≥   u T   b   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  ⌊ ˆ x k ⌋   (7) in the space of structural variables. Finally, (MLP’ k   ) in standard form is max   y m + k   − ⌈ ˆ x k ⌉ f k  s.t.:  Ay   =   A ′   ˆ x   −   b   +   bf k ,  0   ≤   y N   ≤   ˆ x N   ,  0   ≤   y M   ≤   A ′   ˆ x N   −   b, y   ∈   R n   +   m.  (SMLP k ) (SMLP k   ) is in the form of a general LP with lower and upper bounds on the variables. In a basic solution, we denote by   J +   the set of variables which are nonbasic at their upper bound (corresponding to variables   u   and   s   in the dual) and   J −   the set of variables which are nonbasic at their lower bound (corresponding to variables   v   and  t ). We recall that a basic solution of (SMLP k   ) is dual feasible if the reduced costs of every variables in   J −   is non-positive and the reduced cost of all variables in   J +   is non-negative. An immediate property of (SMLP k   ), is that all of its bases are bases of (SLP).  Proposition 6.   The variables indexed by   B   form a base of   (SMLP k )   if and only if they form a base of   (SLP) . Proof.   Since both problems have the same matrix of constraints this is true by defi- nition of bases.  We now turn to the main result of this section which is to characterize the dual feasible bases of (SMLP k ) and to relate them to intersection cuts for (SLP). First, in the next lemma, we characterize the dual feasible bases of (SMLP k ). 15
Lemma 7.   Let   B   =   { i 1 , . . . , i m }   be the index set of a basis of   (SMLP k ) .   B   is dual feasible if either:  (i)   the variable   y m + k   is non-basic at its upper bound, or  (ii)   y m + k   is basic with corresponding tableau row   y m + k + ∑  j ∈ J   a ij   y j   =   a i 0   in   (SMLP k )  and   j   ∈   J   is non-basic at its upper bound if   a ij   <   0   and nonbasic at its lower bound if   a ij   >   0 . Proof.   Let   B   be a basis,   J +   be the set of nonbasic variables at their upper bound and   J −   the set of nonbasic variables at their lower bound. First, we prove the case   (i) .   If   m   +   k   6   ∈   B   then   c B   = 0, therefore all variables have a zero reduced cost except   x m + k   which has a reduced cost of 1 and if   m   +   k   is nonbasic, it has to be at its upper bound for the solution to be dual feasible. Now, we suppose that   m   +   k   ∈   B . We assume that   x m + k   is basic in row   i . The reduced cost of a variable   j   ∈   J   is given by   c j   =   c j   −   c B   A B   − 1 A j   = 0   −   a ij   . Therefore,  B   is dual feasible if for all   j   ∈   J   such that   a ij   >   0,   j   ∈   J −   and for all   j   ∈   J   such that   a ij   <   0,   j   ∈   J + .  Now we study the cuts associated to dual feasible solutions of (MLP). Given a dual feasible basis   B   of (MLP), we will call the cut (7) associated to the solution of (CGLP’ k ) defined by   B , the cut associated to   B . Since we use   B   both as a basis for (SLP) and (SMLP k ), we need to take particular care in denoting the right-hand-sides of the two associated LP tableau’s. We will denote by   b   :=   A B   − 1 b , the right hand side in the tableau of (SLP) and by   a 0   :=   A B   − 1 ( A ′   ˆ x   −   bf k ) the right hand side in the tableau of (SMLP k ). Using the reduced cost computed in Theorem 7, we can compute the values for the dual variables. Using these values the cut (7) can be computed. Keep in mind that by Lemma 3 and remark 4, only dual solutions of negative cost give rise to valid inequalities. Note that in case   (i) , when   y m + k   is non-basic, all dual variables have value 0 except   s k   which is equal to 1. In that case, the dual objective value of the solution is alway non-negative: ˆ x k   − ⌈ ˆ x k ⌉ (ˆ x k   − ⌊ ˆ x k   ⌋ ) =   ⌊ ˆ x k   ⌋ ( ⌈ ˆ x k ⌉ −   ˆ x k )   ≥   0 ,  and therefore no valid inequality can be generated (note that this case is the one exhibited in remark 4). The only case of interest is therefore when   y m + k   is basic. In that case, the values of the dual variables in the basic solution are given by the reduced costs computed 16
above:  u j   =  {  − a ij   if   j   ∈   J +   ∩   M,  0   if   j   ∈   M   \   J +   (8)  v j   =  {  a ij   if   j   ∈   J −   ∩   M  0   if   j   ∈   M   \   J −   (9)  s j   =  {  − a ij   if   j   ∈   J +   ∩   N,  0   if   j   ∈   N   \   J +   (10)  t j   =  {  a ij   if   j   ∈   J −   ∩   N  0   if   j   ∈   N   \   J −   (11) In the following, we will denote by   x   ∈   R n + m   the primal basic solution of (SLP) corresponding to basis   B   First, we show that the dual solution can have a negative cost only if   x m + k   ∈   ] ⌊ ˆ x k ⌋   ,   ⌈ ˆ x k ⌉ [.  Lemma 8.   Let   B   be the index set of a dual feasible basis of   (SMLP k )   such that  m   +   k   ∈   B . Let   x   ∈   R n + m   be the primal basic solution of   (SLP)   corresponding to basis   B . Suppose that   x m + k   6   ∈   ] ⌊ ˆ x k ⌋ ,   ⌈ ˆ x k ⌉ [ , then   ˆ x   is not cut by the dual solution to  (SMLP k   ) . Proof.   By Lemma 3 the dual solution gives a cut for ˆ x   only if   u 0   and   v 0   are positive.  u 0   is given by   u 0   = ( u − v ) T   b + ⌈ ˆ x m + k   ⌉ . Note that ( u − v ) T   b   =   −   ∑  i ∈ M   a ij   b   =   − x m + k . Therefore   u 0   >   0 only if   x m + k   <   ⌈ ˆ x m + k   ⌉ . Similarly since   v 0   = 1   −   u 0 ,   v 0   >   0 only if  x m + k   >   ⌊ ˆ x k ⌋ .  Lemma 8 indicates that the only relevant dual feasible bases for valid cutting planes are those where   x k   ∈   ] ⌊ ˆ x k ⌋ ,   ⌈ ˆ x k   ⌉ [.   Next theorem shows that for those dual feasible bases, the cut derived is the intersection cut obtained from the row of the tableau of (SLP) corresponding to the same basis and the same basic variable. The row of the tableau of (SLP) corresponding to   x m + k   reads  x m + k   +   ∑  j ∈ J  a ij   x j   =   b i  Theorem 9.   Let   B   be the index set of a dual feasible basis of   (SMLP k )   such that  m   +   k   ∈   B . Let   x   ∈   R n + m   be the primal basic solution of   (SLP)   corresponding to this basis. If   x m + k   ∈   ] ⌊ ˆ x k   ⌋ ,   ⌈ ˆ x k ⌉ [ , the cut obtained from the dual solution of   (SMLP k )  corresponding to the basis indexed by   B   is equivalent to the simple intersection cut for   x k   of   (SLP)   obtained from the basis indexed by   B .  17
Proof.   We consider the cut (7) defined by the dual solution.   To show that (7) is equivalent to the intersection cut, we first need to write it in the space with slack variables.  u T   A ′ x N   +   s T   x N   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  x m + k   ≥   u T   b   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k   ⌉  )  ⌊ x k   ⌋ .  We start by replacing   A ′ x N   −   b   with   x M   :  u T   x M   +   s T   x N   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  x m + k   ≥  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  ⌊ x k ⌋ .  Using the values of   u   and   s   given by (8) and (10) this can be rewritten as:  −   ∑  j ∈ J +  a ij   x j   +  (  ( u   −   v ) T   b   − ⌈ ˆ x k ⌉  )  x m + k   ≥  (  ( u   −   v ) T   b   − ⌈ ˆ x k   ⌉  )  ⌊ x k ⌋ .  Noting that ( u   −   v ) T   b   = ( A B   − 1 b ) i   =   b i   the cut can be rewritten as:  −   ∑  j ∈ J +  a ij   x j   +   ( b i   − ⌈ ˆ x k ⌉ )   x m + k   ≥   ( b i   − ⌈ ˆ x k ⌉ )   ⌊ x k ⌋ .  Now using the tableau row of (SLP)   x m + k   +   ∑  j ∈ J   a ij   x j   =   b i , we eliminate   x m + k   :  −   ∑  j ∈ J +  a ij   x j   +   ( b i   − ⌈ ˆ x k ⌉ )   ( b i   −   ∑  j ∈ J  a ij   x j   )   ≥   ( b i   − ⌈ ˆ x k ⌉ )   ⌊ x k ⌋ .  Finally, re-grouping the coefficient, we obtain:  −   ( b i   − ⌊ ˆ x k ⌋ )   ∑  j ∈ J +  a ij   x j   + ( ⌈ ˆ x k ⌉ −   b i )   ∑  j ∈ J −  a ij   x j   ≥   ( b i   − ⌊ ˆ x k ⌋ )( ⌈ ˆ x k   ⌉ −   b i ) .   (12) Since   b i   =   x m + k   ∈   ] ⌊ ˆ x k ⌋ ,   ⌈ ˆ x k   ⌉ [, we have   b i   − ⌊ ˆ x k ⌋   =   b i   − ⌊ b i ⌋ , defining   f 0   :=  b i   − ⌊ b i ⌋   =   x m + k   − ⌊ x m + k ⌋   as in (2), we have that (12) is equivalent to  −   f 0  ∑  j ∈ J +  a ij   x j   + (1   −   f 0 )   ∑  j ∈ J −  a ij   x j   ≥   (1   −   f 0 ) f   0 .   (13) This last cut is identical to the intersection cut (2).   Indeed, if   j   ∈   J + ,   a ij   ≤   0 implies that max {− f 0 a ij   ,   (1   −   f 0 ) a ij   }   =   − f 0 a ij   ; and if   j   ∈   J − ,   a ij   ≥   0 implies that max {− f 0 a ij   ,   (1   −   f 0 ) a ij   }   = (1   −   f 0 ) a ij   . This ends the proof of the Theorem.  18
Theorem 9 implies that every cut obtained from a negative basic feasible solution (CGLP’ k ) is the simple intersection cut obtained from a tableau row of (SLP). We now consider the strengthened cuts obtained from (CGLP’ k ) and show that they are GMI cuts. The strengthened cuts obtained from (CGLP’ k ) are obtained by applying the strengthening operation defined in Section 2.1. To apply the operation, we need to transform our solution of (CGLP’ k ) defined by (8)–(11) to the corresponding solution of (CGLP). This is simply done by taking   u 0   = ( u   −   v ) T   A   +   π 0   + 1,   v 0   = 1   −   u 0 ,  α   =   u T   A   +   s   −   u 0 e k   and   β   =   u T   b .   One can easily check that if   u, v   is feasible for (CGLP’ k ), this solution is feasible for (CGLP).  Theorem 10.   Let   B   be the index set of a dual feasible basis of   (SMLP k )   such that  m   +   k   ∈   B . Let   x   ∈   R n + m   be the primal basic solution of   (SLP)   corresponding to basis   B . If   x m + k   ∈   ] ⌊ ˆ x k ⌋ ,   ⌈ ˆ x k   ⌉ [ , the strengthened lift-and-project cut obtained from the dual solution of   (SMLP k )   corresponding to   B   is equivalent to the GMI cut obtained from basis   B . Proof.   To establish the equivalence, we need to write the strengthened lift-and- project cut obtained from the basis   B .   We recall, that the strengthening consist in replacing the coefficient ˆ α j   := max { u T   A j   , v T   A j   }   with   α j   for   j   = 1 , . . . , p ,   j   6   =   k  where   α j   is given by  α j   := min { uA j   −   u 0 ⌊ m j   ⌋ , vA j   +   v 0 ⌈ m j   ⌉}  where   u, v, u 0   and   v 0   are feasible for (CGLP) and  m j   :=   uA j   −   vA j  u 0   +   v 0  Therefore to obtain the strengthened cut, we need to add   α j   −   ˆ α j   to the coefficient of  x j   obtained in (13) for   j   = 1 , . . . , p ,   j   6   =   k . Next, we verify that doing so one obtains the GMI cut (3). Our first order of business is to build the solution to (CGLP), we take   u   and   v  given by the dual solution corresponding to basis   B   as computed in (8)–(11).   u 0   is then given by   u 0   = ( u   −   v ) T   A   +   π 0   + 1 =   π 0   + 1   −   ˆ x m + k   = 1   −   f 0   (where, as before  f 0   = ˆ x m + k   − ⌊ x m + k   ⌋ ) and   v 0   = 1   −   u 0   =   f 0 . Using the definition of (CGLP’ k ), we can rewrite   m j   as   m j   = ( t j   −   s j   ).   From this, it is immediate that for   j   ∈   B , since   s j   =   t j   = 0,   m j   = 0. Furthermore, from the constraints of (CGLP’ k ) we then have ( u   −   v ) T   A j   = 0 and therefore   α j   = ˆ α j   . This implies that the coefficient of the cut is not changed for   j   ∈   B . 19
We now consider   j   ∈   J   ∩   N I   . In this case, using the value of the dual solution given by (8)–(11), we have   m j   = ( t j   −   s j   ) =   a ij   Summing up everything, so far, we have that the formula for ˆ α j   for   j   ∈ { 1 , . . . , p } \   B   is given by  α j   = min { uA j   −   (1   −   f 0 ) ⌊ a ij   ⌋ , vA j   +   f 0 ⌈ a ij   ⌉} .  To establish the strengthened coefficients, we consider separately the case   j   ∈   J +  and the case   j   ∈   J − . First, assume   j   ∈   J +   ∩   N I   .   Then   a ij   ≤   0,   s j   =   − a ij   and   t j   = 0.   From ( v   −   u ) T   A j   = ( s j   −   t j   ) =   − a ij   ≥   0, we have ˆ α j   =   vA j   and   uA j   =   vA j   +   a ij   therefore:  α j   −   ˆ α j   = min   { vA j   +   a ij   −   (1   −   f 0 )   ⌊ a ij   ⌋   , vA j   +   f 0   ⌈ a ij   ⌉ }   −   vA j   = min   { a ij   −   (1   −   f 0 )   ⌊ a ij   ⌋   , f 0   ⌈ a ij   ⌉}   .  Since   j   ∈   J + , the coefficient for   x j   in (13) is   − f 0 a ij   , the new coefficient is therefore:  −   f 0 a ij   + min   { a ij   −   (1   −   f 0 )   ⌊ a ij   ⌋   , f 0   ⌈ a ij   ⌉}  = min   {− f 0 a ij   +   a ij   −   (1   −   f 0 )   ⌊ a ij   ⌋   ,   − f 0 a ij   +   f 0   ⌈ a ij   ⌉}  = min   { (1   −   f 0 ) ( a ij   − ⌊ a ij   ⌋ )   , f 0   ( ⌈ a ij   ⌉ −   a ij   ) }  Now, we consider the case   j   ∈   J −   ∩   N I   . Then   a ij   ≥   0,   s j   = 0 and   t j   =   a ij   . From ( v   −   u ) T   A j   = ( s j   −   t j   ) =   − a ij   ≤   0, we have ˆ α j   =   uA j   and   vA j   =   uA j   −   a ij   therefore:  α j   −   ˆ α j   = min   { uA j   −   (1   −   f 0 )   ⌊ a ij   ⌋   , uA j   −   a ij   +   f 0   ⌈ a ij   ⌉ }   −   uA j   = min   {−   (1   −   f 0 )   ⌊ a ij   ⌋   ,   − a ij   +   f 0   ⌈ a ij   ⌉}   .  Since   j   ∈   J − , the coefficient for   x j   in (13) is (1   −   f 0 ) a ij   , the new coefficient is therefore: (1   −   f 0 )   a ij   + min   {−   (1   −   f 0 )   ⌊ a ij   ⌋   ,   − a ij   +   f 0   ⌈ a ij   ⌉}  = min   { (1   −   f 0 )   a ij   −   (1   −   f 0 )   ⌊ a ij   ⌋   ,   (1   −   f 0 )   a ij   −   a ij   +   f 0   ⌈ a ij   ⌉}  = min   { (1   −   f 0 ) ( a ij   − ⌊ a ij   ⌋ )   , f 0   ( ⌈ a ij   ⌉ −   a ij   ) }   .  Therefore, for both   j   ∈   J +   ∩   N I   and   j   ∈   J −   ∩   N I   we have that the coefficient for the strengthened cut is min   { (1   −   f 0 ) ( a ij   − ⌊ a ij   ⌋ )   , f 0   ( ⌈ a ij   ⌉ −   a ij   ) }   .   (14) It is trivial to check that this coefficient is the same as the GMI cut coefficient.  20
Note that this theorem allows to complete the results of Lemma 5, by adding the fact that the cut obtained is indeed the intersection cut or GMI cut. Theorems 9 and 10 can be seen as the counterparts of Theorems 4A, 4B and 5 in [12].   Indeed, the statements are almost equivalent except that here the simpler normalization condition   u 0   +   v 0   = 1 is used here whereas the normalization condition ∑ ( u i   +   v i ) +   ∑ ( s i   +   t i ) +   u 0   +   v 0   = 1 was used in [12]. In [6], the theorems of [12] were generalized to weighted normalizations of the form   ∑   ψ i ( u i   +   v i ) +   ∑   ξ i ( s i   +   t i ) +   u 0   +  v 0   =   ψ 0   where   ψ   ∈   R m  +   ,   ξ   ∈   R n  +   and   ψ 0   ∈   Z + . Theorems 9 and 10 can be seen as a particular case of those latter theorems (but the proofs here are simpler and more direct). Another important result in [12] was an algorithm to solve (CGLP) in the tableau of (SLP). Our results show that, with the simpler normalization   u 0   +   v 0   = 1, a similar algorithm to solve (CGLP’) is simply to solve (MLP’ k   ).   We note that a limitation of the algorithm in [12] is that it starts from a basis of (SLP) that gives a cut. If such a basis is not available, the solution of (MLP’ k ) can be seen as an easy way to find one.  5   Optimizing over   P e   and approximating   P e ∗  We now turn back to our initial goal which is the optimization of   P e   and   P e ∗   . To do so, we follow a simple Kelley cutting plane algorithm [35] where the master problem is the LP relaxation of (MILP) augmented with cuts and the cut generation procedure is the solution of (MLP’ k   ). More precisely, at each iteration, we first solve the master problem and obtain a solution   x ∗ .   If   x ∗   is integer feasible, we stop.   Otherwise we solve the separation problem (MLP’ k ) for a number of fractional components of   x ∗  which should be integer. If some of the separation problems lead to a cut (i.e. has negative objective value), we add those cuts to the master problem and iterate. Otherwise, if all (MLP’ k ) for all   k   ∈ { 1 , . . . , p }   such that   x ∗  k   6   ∈   Z   have non-negative objective value, we have a proof that   x ∗   ∈   P e .   To approximate   P e ∗   , we simply strengthen every cut derived by the usual strengthening procedure as done in the proof of Theorem 10. Note that cuts are never added to (MLP’ k   ) in the course of the procedure (i.e. we stick to generating rank one cuts only). This simple algorithm should terminate in a finite number of iterations (since there are only a finite number of rank 1 cuts) but there is no complexity guarantee. Also concerning   P e ∗   there is no guarantee of how good is the approximation. Nevertheless, it is guaranteed that approximating   P e ∗   in this way will give a better bound than optimizing   P e   and since the extra computational cost is negligible, it should always be better. Note that this approach is similar to the one presented in [19] although it is presented there from a different point of view. In [19], a Benders decomposition is 21
applied to a linear programming model of   P e   defined in a higher dimensional space. Applying this decomposition amounts to performing the cut generation method out- lined above.   The main difference between the two approaches is the separation problem that is solved. In [19], a (CGLP) is solved while here we solve (MLP) (other differences are the details of our algorithm that are described below). In order to make this algorithm somewhat efficient, one drawback has to be taken care of. In the course of the algorithm, it often happens that although   x ∗  k   is fractional the solution of (MLP’ k ) does not lead to a cut. If at a given iteration, this happens for all   k   ∈ { 1 , . . . , p } , this gives the useful information that   x ∗   ∈   P e   (and stops the algorithm) but if it only happens for some   k ’s it only indicates that   x ∗   ∈   P   ( e k , ⌊ x ∗  k   ⌋ )   but does not help the algorithm in progressing. After the first iteration, this phenomenon usually happens very frequently, and if not taken care of, a significant part of the computation can be spent in solving those separation problems that do not lead to a cut.   To try to overcome it, at each iteration we solve (MLP’ k   ) only for those   k  which led to a cut in the previous iteration.   Of course, to maintain the validity of the algorithm, in the case when no cuts were generated, we need to test all the variables (we also test all the variables in the case where some tailing off is detected). This strategy is obviously not perfect as still some problems (MLP’ k ) will not lead to cuts but it greatly improves the efficiency of the procedure (more comments on the practical performance will be made in Section 6.1).   The pseudo-code of the algorithm we apply to approximate   P e ∗   is given in Algorithm 1. A second aspect where we try to make our algorithm more efficient is in trying to make the solutions time of the problem (MLP’ k ) as small as possible.   At each iteration of the algorithm in Step 4, we solve a sequence of such problem for a number of integer constrained variables   k 1 , . . . , k p . As can be expected, the problem are solved by the simplex algorithm, and a main question is which starting basis to use.   Note that from one problem to the next, in general, all bounds on variables and constraints are changed as well as the objective function.   Therefore, we can not expect the optimal basis of (MLP’ k i   ) to be either primal or dual feasible for (MLP’ k i +1   ).   There is one simple exception to this, if ˆ x k i   = ˆ x k i +1   , both problems have the same constraint system and therefore the solution of (MLP’ k i   ) is primal feasible for (MLP’ k i +1   ). We try to benefit from this by solving the problems (MLP’ k ) in increasing order of the value ˆ x k   (also hoping that if ˆ x k i   is close to ˆ x k i +1   , the solution of (MLP’ k i   ) will be close to being primal feasible for (MLP’ k i +1   )).   Again, we do not claim that our strategies are the best possible but just try to follow some sound heuristics rules, the computation in the next section will illustrate the practical performance. 22
Algorithm 1   Cutting plane algorithm for   P e ∗  0.   Initialize feasible region.  C ← { x   ∈   R n  +   :   A ′ x   ≥   b } . 1.   Initialize variables list  K ← { 1 , . . . , p } ,   reinit   ←   true . 2.   Master Problem  Solve max { c ′ T   x   :   x   ∈   C } . Let ˆ x   be the solution. 3.   Filter variables  F ← { i   ∈ K   : ˆ x i   − ⌊ ˆ x i ⌋ ≥   ǫ } ,   K ← ∅ . Sort   F   by increasing values of ˆ x k   . 4.   Separate  For each   k   ∈   F   solve (MLP’ k   ).   If the solution is   ≤   − ǫ   construct strengthened cut   α T   x   ≥   β   from its dual solution and let   K ←   K   ∪ { k } ,  C ←   C   ∩ { x   :   α T   x   ≥   β } . 5.   Termination  If   K   =   ∅   and   reinit   =   true , then   STOP . 6.   Loop  If   K   =   ∅   or tailing off is detected, then   go to 1 , else   reinit   ←   f alse ,   go to 2.  6   Computational results  We now present some computational experiments aimed at assessing the interest of our procedures for optimizing over   P e   and approximating   P e ∗   .   The computations are performed with an implementation of Algorithm 1 in C++. The code allows the use of two different LP solvers Clp [32] from COIN-OR [36] and IBM CPLEX. For efficiency reasons, the code calls each solver directly by using their respective native C++ and C API. All experiments are conducted on a machine equipped with Intel Quad Core Xeon 2.93GHz processors and 120 GiB of RAM, using only one thread for each run.   We use Clp version 1.11 and Cplex version 12.   The tolerance   ǫ   in Algorithm 1 is set to 10 − 4   and a time limit of 1 hour is imposed.   Note also that since the number of cuts generated can sometime grow very large, we use a cut pool to keep the size of the master problem reasonable. Our main goal in these experiment is to assess how useful a relaxation   P e ∗   can be and how quickly it can be computed. First, we will present computations of   P e   and  P e ∗   on a large set of problems. Next, we present several comparisons with different methods:  •   first, a comparison in terms of gap closed with textbook GMI cuts and lift- 23
and-project cuts generated by rounds;  •   second, a comparison with several other methods recently proposed to generate rank-1 cuts: the heuristics proposed by Dash and Goycoolea [25], the relax-and- cut framework proposed by Fischetti and Salvagnin [31], the new reduce-and- split proposed by Cornu ́ ejols and Nannicini [24] and finally the computations of the GMI/MIR closure made by Balas, Saxena [13] and Dash, G ̈ unl ̈ uk, Lodi [26];  •   finally, some preliminary experiments on using   P e ∗   in a branch-and-cut frame- work. All experiments are performed on MIPLIB3 [15] and MIPLIB 2003 [37] problems. Before proceeding to the results, let us remind that computations of   P e ∗   were already conducted in [19] and stress the differences with the current paper and the interest of the new experiments presented here.   The approach in [19] used a cut generation LP formulated in a higher dimensional space.   Although it is possible that each cut separated was deeper there, the size of the cut generation LPs and their solution time limited the applicability of the approach to small and medium size problems. For that reason the computational experiments in [19] were limited to problems with up to 1000 variables. We did not carry out systematic comparison between the two approaches but let us note that on the test set used in [19] our code is about 12 times faster than the results reported there (although our tolerances are likely to be stricter). This is certainly in part due to faster machines and faster LP codes but we believe also to the use of a better separation LP. One main interest of the experiments here is that thanks to these faster computing time we are able to report numbers on the complete MIPLIB 3 and MIPLIB 2003 problems.  6.1   Computation of   P e   and   P e ∗  We ran our code to compute   P e   and approximate   P e ∗   on 62 MIPLIB 3.0 instances 1  and 20 MIPLIB 2003 instances that are not already in MIPLIB 3.0. We have ran each instance with four variants of the code: computation of   P e   and approximation of   P e ∗  both with Clp and CPLEX as LP solver. The code is run on the original instance without any preprocessing.   The results of these experiments are summarized in Tables 1 and 2. For each test problem, we report the CPU time and the fraction of the integrity gap closed by the method.  1 We do not report computations on   markshare1 ,   markshare2   and   pk1 , because our code ran into computational troubles on these two instances when using CPLEX as LP solver. Note however that no gap is closed either by   P e   or   P e ∗  24
Table 1: CPU time and gap closed by   P e   and   P e ∗   on MIPLIB 3.0.  P e   P e ∗  Clp   CPLEX   Clp   CPLEX  name   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap  10teams   3600   0   3600   31.31   3600   100   3600   100 air03   1.24   100   0.36   100   0.86   100   0.39   100 air04   3600   41.34   3600   83.71   3600   53.66   3600   91.29 air05   3600   49.98   3600   65.43   3600   57.90   3600   68.11 arki001   6.01   20.34   15.59   20.34   3.42   35.59   4.51   36.44 bell3a   0.01   64.56   0.02   64.56   0.01   64.56   0.01   64.56 bell5   0.06   86.25   0.04   86.25   0.04   86.55   0.03   86.55 blend2   0.11   21.82   0.08   21.82   0.08   22.01   0.06   22.54 cap6000   3.45   50   0.89   50   1.30   62.50   0.25   56.25 dano3mip   3600   0.20   3600   0.51   3600   0.22   3600   0.52 danoint   3600   4.75   245.25   5.57   3600   5.06   213.79   5.97 dcmulti   2.47   98.15   1.67   98.15   1.94   98.76   0.85   98.19 dsbmip   3600   no   gap   0.60   no   gap   3600   no   gap   0.98   no   gap egout   0.05   93.85   0.03   93.85   0.04   93.85   0.02   93.85 enigma   1.06   no   gap   3.92   no   gap   5.57   no   gap   0.42   no   gap fast0507   3600   3.01   3600   8.58   3600   2.91   3600   11.35 fiber   9.35   20.63   2.60   20.63   1.41   93.55   0.59   97.10 fixnet6   76.64   86.36   17.79   86.36   37.88   86.53   11.32   87.12 flugpl   0.00   11.72   0.00   11.72   0.00   11.72   0.00   11.72 gen   3.74   70.49   2.03   70.49   0.38   82.51   0.20   93.99 gesa2   2.10   59.10   1.38   59.10   1.14   66.06   0.60   67.38 gesa2   o   2.23   59.80   1.75   59.80   1.56   65.20   0.81   72.66 gesa3   16.71   79.95   7.06   79.95   3.19   94.40   1.19   94.59 gesa3   o   20.61   82.88   6.83   82.88   2.75   94.40   1.38   94.40 gt2   0.03   92.38   0.02   92.38   0.04   98.34   0.02   98.58  25
Table 1 (continued): CPU time and gap closed by   P e   and   P e ∗   on MIPLIB 3.0.  P e   P e ∗  Clp   CPLEX   Clp   CPLEX  name   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap  harp2   29.88   21.28   4.65   21.28   7.27   50.39   5.02   56.03 khb05250   0.52   99.86   0.32   99.86   0.29   99.95   0.28   99.95 l152lav   333.68   34.46   36.98   34.46   200.71   61.64   20.55   64.53 lseu   0.03   16.58   0.02   16.58   0.02   77.45   0.01   69.59 mas74   0.18   5.47   0.06   5.47   0.05   7.95   0.04   8.06 mas76   0.26   3.68   0.06   3.68   0.05   7.32   0.02   7.32 misc03   2.48   40.21   0.63   40.21   1.64   40.21   0.49   40.21 misc06   0.60   89.66   0.29   86.21   0.48   95.40   0.21   87.36 misc07   18.17   11.44   6.74   11.44   14.18   13   4.71   13.31 mitre   914.05   100   131.19   100   6.61   100   3.48   100 mkc   3600   50.60   26.72   63.18   3600   62.82   84.80   64.03 mod008   0.08   9.02   0.03   9.02   0.04   37.36   0.02   37.58 mod010   183.37   52.51   17.10   52.51   1.86   100   0.11   100 mod011   3600   39.41   3600   53.46   3600   39.48   3600   56.24 modglob   0.51   57.09   0.30   57.09   0.72   57.09   0.47   61.91 noswot   3600   0   0.06   0   3600   0   0.08   0 nw04   3600   35.19   3600   37.71   3600   97.62   194.03   100 p0033   0.01   8.19   0.01   8.19   0.01   57.76   0.01   76.40 p0201   0.75   46.85   0.61   46.85   1.30   69.75   0.87   71.51 p0282   0.50   93.90   0.21   93.90   0.47   98.41   0.27   98.69 p0548   2.66   91.35   1.65   91.35   3.12   94.27   1.06   95.33 p2756   5.72   81.59   2.89   81.60   4.21   98.90   1.18   96.31 pp08a   0.25   79.29   0.13   79.29   0.26   79.29   0.15   79.29 pp08aCUTS   0.69   68.81   0.43   68.81   0.76   70.17   0.55   69.09 qiu   3600   76.20   979.10   78.10   3600   69.63   1712.86   78.10 qnet1   15.59   94.28   15.30   94.28   22.77   94.49   15.48   96.27 qnet1   o   2.07   87.59   2.89   87.59   2.08   89.74   4.03   89.78 rentacar   3600   63.22   3600   90.28   3600   75.68   3600   98.51 rgn   0.18   11.88   0.21   11.88   0.12   73.65   0.04   69.88 rout   161.12   28.01   18.61   28.01   12.63   52.18   2.40   55.24 set1ch   0.64   39.88   0.42   39.88   0.77   39.88   0.31   39.88 seymour   3600   3.72   2624.25   55.94   3600   4.46   3144.46   57.69  26
Table 1 (continued): CPU time and gap closed by   P e   and   P e ∗   on MIPLIB 3.0.  P e   P e ∗  Clp   CPLEX   Clp   CPLEX  name   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap  stein27   0.29   0   0.33   0   0.26   0   0.48   0 stein45   8.72   0   23.90   0   10.67   0   17.54   0 swath   48.53   2.77   13.00   2.77   22.07   26.31   5.52   26.31 vpm1   0.18   31.42   0.11   31.42   0.12   36.07   0.09   33.17 vpm2   0.47   54.29   0.22   54.29   0.40   54.36   0.18   54.41  Table 2: CPU time and gap closed by   P e   and   P e ∗   for MIPLIB 2003.  P e   P e ∗  Clp   CPLEX   Clp   CPLEX  name   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap  a1c1s1   1509.64   78.68   141.93   78.75   706.01   78.72   154.91   78.85 aflow30a   8.19   42.41   2.42   42.41   4.72   42.61   2.05   43.21 aflow40b   69.58   34.29   14.02   34.29   25.37   35.18   12.11   35.84 atlanta-ip   3600   0.02   3600   1.71   3600   0.02   3600   1.09 glass4   13.99   0   1.01   0   10.96   0.09   1.82   0.08 momentum1   3600   30.47   3600   41.09   3600   30.11   3600   42.80 momentum2   3600   19.15   3600   41.96   3600   11.69   203.17   41.34 msc98-ip   3600   0.88   3600   42.26   3600   1.19   3600   44.55 mzzv11   3600   6.54   3600   51.23   3600   10.97   3600   98.37 mzzv42z   3600   4.53   3060.04   87.74   3600   14.66   371.54   100 net12   3600   5.71   3600   22.78   3600   4.70   3600   22.62 nsrand-ipx   1794.49   36.88   292.98   36.88   63.55   75.38   28.55   77.70 opt1217   2.32   0.19   0.78   0.19   1.53   23.54   17.67   30.10 protfold   3600   6.84   3600   10.29   3600   8.34   3600   7.80 rd-rplusc-21   3600   0   3600   0   3600   0   3600   0 roll3000   721.17   16.30   163.90   16.30   547.61   54.11   139.12   56.27 sp97ar   3600   42.04   570.42   42.06   3600   57.47   828.83   59.94  27
P e   P e ∗  Clp   CPLEX   Clp   CPLEX  name   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap   CPU(s)   % gap  timtab1   0.66   26.99   0.40   26.99   0.61   42.31   0.36   42.45 timtab2   1.98   20.98   1.16   20.98   3.31   42.69   1.07   40.18 tr12-30   7.91   64.12   4.16   64.12   6.49   64.13   3.33   64.12  Several remarks can be made from these results.   First the proportion of the integrity gap closed is significant on most instances.   There are only 5 instances ( stein27, stein45, glass4   and   rd-rplusc-21 ) on which no gap is closed.   On average, on MIPLIB 3.0,   P e   closes 47 . 12% of the integrity gap with Clp and 50 . 40% with CPLEX, while on MIPLIB 2003 the gap closed is 21 . 85 and 33 . 1% respec- tively (note that these differences are mostly due to problems which go to the time limit).   Approximating   P e ∗   closes significantly more gap:   on MIPLIB 3.0 60 . 15% and 63 . 42% with Clp and CPLEX respectively, on MIPLIB 2003 29 . 9% and 44 . 37%. The computations on   P e ∗   highlight the heuristic nature of the approximation since the gap closed can be significantly different depending on the LP solver used (while the results are usually similar for   P e ). Finally, computing times vary a lot between instances but are usually close between the four methods.   In total, for   P e ∗   with CPLEX (our best method) 14 problems go to the time limit (7 in MIPLIB 3.0 and 7 in MIPLIB 2003). 7 out of these 14 can be solved to optimality in a shorter comput- ing time with CPLEX ( 10teams, air04, air05, fast0507, rentacar, qiu   and  mzzv11 ), 6 would take longer than an hour ( atlanta-ip, momentum1, msc98-ip, net12 ,   protfold   and   rd-rplus-sc21 ) and one is an open problem ( dano3mip ). In spite of these instances, computing times are typically small with a geometric mean of 5.02 and 1.79 seconds respectively for   P e ∗   with Clp and CPLEX on MIPLIB 3.0, and 233 and 119 seconds respectively on MIPLIB 2003. Note that computing times are often slightly higher for   P e . This is not surprising since our stopping criterion is that the point   x ∗   belongs to   P e   and that the cuts generated in   P e ∗   are always deeper. In table 3, we give geometrical means for a number of key statistics of our pro- cedure: the number of master iterations of the procedure (i.e. the number of times step 2 of Algorithm 1 is performed), the CPU time spent to solve the master problem (i.e. the total time spent in step 2), the total number of time a separation problem (MLP’ k ) was solved, the number of times it led to a cut, the number of times it did not lead to a cut, the CPU time spent to solve separation problems, and finally the total number of simplex iterations for solving separation problems.   Statistics refer to the runs approximating   P e ∗   with CPLEX as LP solver. Averages figures are given on three sets of problems: all instances of MIPLIB 3.0, all instances in MIPLIB 3.0 28
that took more than 1 second of CPU time and all instances solved within the time limit.  MIPLIB 3   >   1s. CPU   finished  # Master iterations   56.6   141.3   47.3 total resolve time   0.4   17.43   0.14 # (MLP’ k   ) solved   563.4   2844.5   433.10 # cuts   514   2749   335.7 # non-cut   49.4   95.5   97.4 total (MLP’ k   ) time   0.5   14.21   0.21 total (MLP’ k   ) pivots   7,624   140,599   3,781  Table 3: Detailed statistics of   P e ∗   approximation on MIPLIB3 problems. The main observation we can make from table 3 is that the time to solve (MLP’ k ) is usually very small: on average it takes 8 . 910 − 4   seconds to solve if we consider the whole of MIPLIB 3.0, 5 . 010 − 3   seconds if we restrict to problem that took more than 1 second of CPU time. This can be explained by the number of pivots which is also small with about 13 pivots on average on MIPLIB 3.0 (49 if we restrict to problems that took more that 1 sec.).   This is also illustrated by the fact that in total re- solving the LP relaxations after adding cuts takes about the same time as solving (MLP’ k )’s. Another interesting figure is the proportion of separation problems that led to a cut. Here one should only look at the statistics for problems that are finished (other statistics are biased by unfinished problems where the proportion of cuts is typically much higher), on average 22 % of (MLP’ k )’s did not lead to a cut.  6.2   Comparison with GMI and lift-and-project cuts  We now turn to the comparison with GMI and lift-and-project cuts.   To perform this comparison, we use a standard implementation of a GMI cuts (following [9]) generator that we developed using COIN-OR and the publicly available code for generating lift-and-project cuts   CglLandP   [17, 6]. We run both codes with different number of rounds. First we compare the gaps closed after one round of cuts. The goal of this is to compare the gap closed by rank-1 cuts using   P e   and   P e ∗   with the gap closed by the rank-1 cuts generated by more classical methods. Second, we compare the gaps closed after 10 rounds of cuts. This is a reasonable setting for cut generators in a branch and-cut procedure. Finally, we compare the gaps closed after 100 and 50 rounds of cuts for GMI and lift-and-project respectively.   Since the computing 29
time for   P e ∗   are rather high compared to 10 rounds, this last setting is to see if when given a large number of rounds GMI and lift-and-project cuts can approach   P e ∗   . Of course, as more round are performed, the rank of the GMI and lift-and-project cuts increases (Fischetti, Lodi and Tramontani have experimented that it typically increases faster with GMI cuts [29]). Since both codes for GMI and lift-and-project cuts work only with   Clp , we compare with our runs using the same solver. In Table 4, we report geometrical means of the computing times and averages of gap closed for each method on MIPLIB 3.0.  time (sec.)   % gap closed  P e   8.08   47.12  P e ∗   5.02   60.15 1 GMI round   0.00   25.74 10 GMI rounds   0.04   44.39 100 GMI rounds   0.45   49.80 1 l-a-p round   0.04   26.38 10 l-a-p rounds   1.63   52.88 50 l-a-p rounds   9.36   57.62  Table 4: Comparison between   P e   and   P e ∗   with GMI cuts and lift-and-project cuts generated by rounds. Geometrical means of CPU times and average gap closed. Several remarks are in order.   First, comparing rank-1 cuts only, we note that the gap closed with   P e   and   P e ∗   is considerably bigger than the one closed by either GMI or lift-and-project cuts. Of course, this requires a much higher computing time. Iterating GMI and lift-and-project cuts, the gap closed never reaches the one closed by   P e ∗   . After 100 rounds of GMI it is only slightly higher than the gap closed by   P e . The gap closed by lift-and-project cuts after 10 and 50 rounds is significantly bigger than with GMI cuts and with   P e   but it is still smaller than with   P e ∗   , while the CPU time becomes bigger for 50 rounds. Due to the tailing off effect encountered when generating GMI and lift-and-project cut by rounds, it is likely that GMI generated in this fashion will never reach the gap closed by   P e ∗   and lift-and-project cut would probably have much difficulties.  6.3   Comparison with other methods based on rank-1 cuts  To finish our comparisons of gaps closed, we compare our results with several recent related works that also aim at separating rank 1 cuts. First, we make a comparison 30
with the computations of the split (or equivalently MIR) closure performed by Balas and Saxena [13] and Dash, G ̈ unl ̈ uk and Lodi [26].   The split closure is a tighter relaxation than ours, but the computing times are usually very high (hours). It is therefore interesting to know how close we are able to approach those results with our comparatively fast procedure.   Secondly, we make a comparison with two methods that are also aimed at generating rank-1 GMI cuts from basic tableau’s.   The first of these was proposed by Dash and Goycoolea [25] and consists of several heuristics for finding violated rank-1 GMI cuts. The second of these is a framework based on generating GMI cuts and relaxing them in a Lagrangian fashion proposed by Fischetti and Salvagnin [31].   Finally, we make a comparison with another recent work by Cornu ́ ejols and Nannicini [24] that aims at generating more rank-1 split cuts by a reduce-and-split approach. The test instances we consider are a subset of MIPLIB 3.0 and the MIPLIB 2003 that were used in [25, 31] (split closure computations are only available for MIPLIB 3.0). In Table 5, we report the average gap closed by the split closure (for each prob- lem we took the strongest value from [13] and [26]), Dash and Goycoolea method, Fischetti and Salvagnin method, and our method for   P e ∗   .   Both [25] and [31] have proposed several variants of their methods, to make the comparison concise we se- lected only one for each approach:   the   default   approach of Dash and Goycoolea and the   fast   approach of Fischetti and Salvagnin. We also report indication of com- puting times. Note that these times should be considered with much care because experiments have been performed on different machines with different CPUs and dif- ferent LP solvers. The computing times in [25] refer to a 1.4 GHz PowerPC machine for MIPLIB3.0 and to a 4.2 PowerPC machine for MIPLIB 2003.   The computing times in [31], refer to a 2.4GHz Intel Q6600.   As can be seen from the table, the split closure is significantly stronger than any of the three methods using GMI cuts from tableau’s closing 79.2% of the gap on MIPLIB 3.0 versus between 59.6% and 64.9% for the three GMI methods. This can be seen as relatively far, but given the significantly shorter computing times of all three methods, it can also be seen as a fairly good approximation (note that on 9 instances our approach closes more gap than [13] and [26]). Comparing the three GMI methods, our approximation of   P e ∗  closes the most gap on MIPLIB 3.0 and [31] closes the most gap on MIPLIB 2003. The computing times of [31] and ours are close ([31] is slightly slower on MIPLIB 3, but quite faster on MIPLIB 2003), while [25] seems to be somewhat slower (note that besides the different CPUs, the three methods have different termination criterion). An important element not conveyed by average figures is that none of the three GMI methods dominates the other two: each closes the most gap on some instances. On MIPLIB 3.0,   P e ∗   closes more gap than the other two for 16 instances, [31] closes 31
more gap for 10 and [25] closes more gap for 14. On MIPLIB 2003,   P e ∗   closes more gap for 7 instances, [31] for 8 and [25] for 4.   Another method to compute split  method   MIPLIB 3.0   MIPLIB 2003  time   1   % gap   time   1   % gap  Split closure (best from [13, 26])   7556   79.2   —   — Heuristic rank-1 GMI cuts [25]   20.05   61.6   854   39.7 Relax and GMI cuts [31] ( fast )   2.25   59.6   58.4   45.4  P e ∗   approximation   1.36   64.4   119   44.4  Table 5: Comparison of methods for rank-1 GMI cuts from tableau’s . cuts that differs from traditional GMI cuts from the tableau is the reduce-and-split method [1]. The method was recently re-explored and enhanced by Cornu ́ ejols and Nannicini [24].   In Table 6, we compare the gap closed by our method to the gap closed in [24] and the Split Closure. The test set consists only of the Mixed models in MIPLIB 3.0 since reduce-and-split is particularly aimed at those. The gap closed reported in [24] correspond to the gap closed by one round of several cut generators for in the Cgl library (GMI cuts, MIR cuts, lift-and-project, two-step MIR, cover, flow covers) plus several variants of the reduce-and-split cuts.   On these instances our method closes more gap on average than the combination of rank-1 cuts in [24]. Again it is important to note that our method does not dominate [24] and we close less gap on 9 instances.  method   % gap  Split closure   78.64  P e ∗   60.77 Reduce and split + CglCuts [24]   50.33  Table 6: Comparison with reduce and split cuts on mixed models in MIPLIB 3.0. To conclude this section, we emphasis that all the rank-1 methods compared here complement each others. As noted several times, no method is dominating the others.   Combining the four methods, even in a trivial way, should give a better approximation of the split closure.  1 timings on different machines  32
6.4   Branch-and-cut computations  The experiments reported in the last three subsections show that our approach based on   P e ∗   seems competitive for building a strong relaxations at least for MIPLIB prob- lems.   Of course, our ultimate goal is to be able to solve those problems faster. Applying our method in a branch-and-cut setting is not straightforward. First, the computing times, although small on average, are certainly higher than any of the cutting plane techniques already available in solvers. It can sometime be even larger than the total CPU time taken by a state-of-the-art solver such as CPLEX. Second, state-of-the art solvers combine many different cut generators and we need to include our method in the cut generation loop. Finally, although the gap closed is intuitively a good measure of the quality of a relaxation, many different factors can influence the performance in a branch-and-cut.   Here, we present a preliminary attempt to deal with those issues and use   P e ∗   in a branch-and-cut setting. To setup the experiment, we use the callback system of CPLEX in order to include our procedure in its branch-and-cut loop. Note that our procedure can be included in two ways. Since the outer loop of our procedure is similar to a classical cut generation loop, we could try to include our procedure by just adding the inner loop (steps 3 and 4 of Algorithm 1) as a cut callback. This would have nevertheless the disadvantage that we would loose some control on the termination of the procedure.   Therefore, we follow the more simple approach to run the complete procedure described by Algorithm 1 (i.e. except for the context in which it is used it is the same procedure as before). We call our procedure only once at the root node.   Since, CPLEX has its own cutting plane procedures which are usually faster than ours, we should try as much as possible to benefit from them. In particular, even though we don’t use the cuts generated by CPLEX in our separation LP, our procedure can benefit from CPLEX cutting planes because the point to cut should be closer to   P e ∗   after several rounds of cutting planes. For this reason, we try to call our procedure at the end of CPLEX cut generation loop.   Since, as far as we know, there is no direct way of knowing if CPLEX has decided that it has exhausted its own cut generators, we attempt to detect it as follows: each time CPLEX calls our callback, we record the number of cuts generated for each class of cuts that CPLEX has, if from one iteration to the next none of those number changed, we launch our cutting plane procedure. At the end of the procedure, we pass to CPLEX all the cuts we found that are binding at the current optimum. Note that many decisions that could impact the efficiency of our procedure in a branch-and-cut can be made. For example, cut generation procedures usually have policies to reject cuts that are too dense or deemed numerically unstable.   Also, 33
our termination criterion and the tolerances we use may be too tight for practical purposes.   In this preliminary experiment, we do not intend to settle these issues. First, we want to keep the results in line with those of the previous sections. Second we believe that those issues can be addressed in different ways and should be the subject of further research.   Our goal is just to give a preliminary view of how a procedure such as ours could be used, and what issues should be dealt with. To test our procedure, we run it on the same set of MIPLIB 3.0 and MIPLIB 2003 problems that we used in Section 6.3. We run two settings. First, the default CPLEX branch-and-cut algorithm (we don’t use dynamic search since it is disabled when a cut callback is used in CPLEX) denoted   CPLEX-BAC . Second, CPLEX augmented with our cut callback denoted   CPLEX + P e ∗   . Note that, we apply our method to the preprocessed model of CPLEX. In both settings, we set a global time limit of 3 hours of CPU time (CPLEX is run on 1 thread).   To report the results, we group the instances in three sets:   set A   consists of 37 instances that are solved with both  CPLEX-BAC   and   CPLEX + P e ∗   in less than 10 seconds,   set B   contains 16 instances that are not in set A but are solved by all our setups, finally   set C   are 8 instances that could not be solved by any setup. Two instances do not belong to any of these sets and are reported separately:   danonint   is solved by   CPLEX-BAC   but not by   CPLEX + P e ∗   ,  nsrand-ipx   is solved by   CPLEX + P e ∗   but not by   CPLEX-BAC . For   CPLEX + P e ∗   , we test two time limits for the   P e ∗   procedure a short time limit of 10 seconds (denoted  CPLEX + P e ∗   -10), and a long one of 1800 seconds (denoted   CPLEX + P e ∗   -1800). We report the results in Table 7. For each set of instances, we report the average gap closed at the root, the geometrical means of CPU time and number of nodes processed and the average final gaps. The result shows that we are still able to generate violated rank-1 cuts after CPLEX has generated all its cuts. Our methods allows to close 12 . 7% more gap at the root for instances in set A, 13 . 6% for instances in set B with a time limit of 10 seconds and 25 . 4% with a time limit of 1800 seconds.   For instances in set C, the difference is less significant: 1 . 5% and 5 . 5% with a time limit of 10 and 1800 seconds respectively. Unfortunately, the improvement in terms of gap closed at the root does not carry out in terms of total solution times. For instances in set A the CPU time is more than 3 times bigger and for instances in set B it is around two time bigger with   CPLEX + P e ∗   –10 and 5 times bigger for   CPLEX + P e ∗   –1800. For instances in set C, the gap closed after 3 hours is on average smaller with   CPLEX + P e ∗   –10. The results in terms of number of nodes are not as grim.   The node reduction is limited with  CPLEX + P e ∗   –10, but with   CPLEX + P e ∗   –1800 we are able to divided the total number of nodes by 2 on set B . 34
method   root % gap   time   # nodes   final gap  Instances in   set A  CPLEX-BAC   73.2   0.12   69.55   0  CPLEX + P e ∗   85.9   0.39   41.04   0  Instances in   set B  CPLEX-BAC   32.4   46.64   11723   0  CPLEX + P e ∗   –10   46.0   93.85   10414   0  CPLEX + P e ∗   –1800   58.8   238.15   5461.31   0  danoint  CPLEX-BAC   2.92   7993   1119303   0  CPLEX + P e ∗   –10   3.68   >   10800   >   585297   44.9  CPLEX + P e ∗   –1800   5.8   >   10800   >   188971   32.6  nsrand-ipx  CPLEX-BAC   50.03   >   10800   > 849402   84  CPLEX + P e ∗   –10   76.8   3449   220105   0  CPLEX + P e ∗   –1800   79.8   892.74   52780   0  Instances in   set C  CPLEX-BAC   23.2   >   10800   >   31339   45.5  CPLEX + P e ∗   –10   24.7   >   10800   >   19066   42.7  CPLEX + P e ∗   –1800   28.7   >   10800   >   4383   42.5  Table 7: Summary of results with branch-and-cut. 35
7   Conclusions  In this paper we proposed a procedure to approximate   P e ∗   .   Our approach seems competitive at least for strengthening the initial formulation and closing integrity gap and is also relatively fast compared to previous similar approaches. These results are another illustration of the strength of low rank cuts. The competitive CPU times are largely due to the separation procedure we use. As our experiment show, we are usually able to generate violated rank-1 cuts very quickly. A possible source of improvement for the procedure in terms of CPU time, would be to use the separation oracle in a framework that would have better convergence properties than the Kelley cutting plane method. It is well known that the Kelley method has slow convergence. Recently, Fischetti and Salvagnin proposed an in-out scheme for optimizing   P e   which bears many similarities with our approach [30]. The computational results they report do not seem competitive to ours in terms of CPU time but they are able to reduce significantly the number of iterations compared to a Kelley approach. These results g ive hope that the CPU times to compute   P e   could still be significantly reduced (note however that adapting their approach does not seem trivial to us). Another source of improvement would be to use the Balas Perregaard algorithm to strengthen the cut obtained by solving (MLP). From a theoretical point of view, this is a straightforward thing to do.   One just need to give the optimal basis of (MLP) as a starting point of the Balas Perregaard algorithm.   Unfortunately, it is much more involved in practice, in particular if one want to keep the separation efficient in terms of CPU time. Finally, we would like to emphasize the interest of finding an exact procedure to optimize   P e ∗   . From the combination of our computational results and those contained in [25, 31], we can try to get a feeling of how far our respective approximations of  P e ∗   are from being optimal.   On the MIPLIB 3.0 test set, our respective average strengthening are 64 . 4%, 61 . 6% and 59 . 6% of the integrity gap closed. If we combine the three methods by taking the best result of the three methods on each instance the average goes up to 70 . 9%. This certainly shows that the three methods are still far from the value of   P e ∗   . Note that even if we add up the computing times of the three procedures, the average CPU time is still a small fraction of the time to compute the split closure which closes 79 . 2% of the integrity gap. As stated in introduction, as far as we know, the complexity of optimizing   P e ∗   is open. These numbers give a computational motivation for attempting to settle the question. 36
References  [1] K. Andersen, G. Cornu ́ ejols, and Y. Li. Reduce-and-split cuts: Improving the performance of mixed integer Gomory cuts.   Management Sci. , 50(11):1720– 1732, 2005. [2] K. Andersen, G. Cornu ́ ejols, and Y. Li.   Split closure and intersection cuts.  Mathematic Programming , 102:457–493, 2005. [3] E. Balas.   Disjunctive programming.   Annals of Discrete Mathematics , 5:3–51, 1979. [4] E. Balas. Disjunctive programming and a hierarchy of relaxations for discrete op- timization problems.   SIAM J. Algebraic Discrete Methods , 6(3):466–486, 1985. [5] E. Balas. Disjunctive programming : Properties of the convex hull of feasible points.   Discrete Applied Mathematics , 89:3–44, 1998. (originaly MSRR # 348, Carnegie Mellon University, July 1974). [6] E. Balas and P. Bonami. Generating lift-and-project cuts from the LP simplex tableau: open source implementation and testing of new variants.   Mathematical Programming Computations , 1:165–199, 2009. [7] E. Balas, S. Ceria, and G. Cornu ́ ejols. A lift-and-project cutting plane algorithm for mixed 0-1 programs.   Math. Programming , 58:295–324, 1993. [8] E. Balas, S. Ceria, and G. Cornu ́ ejols.   Mixed 0-1 programming by lift-and- project in a branch-and-cut framework.   Management Sci. , 42:1229–1246, 1996. [9] E. Balas, S. Ceria, G. Cornu ́ ejols, and N. Natraj. Gomory cuts revisited.   Oper- ations Research Letters , 19:1–9, 1996. [10] E. Balas and R. G. Jeroslow.   Strengthening cuts for mixed integer programs.  European J. Oper. Res. , 4(4):224–234, 1980. [11] E. Balas and M. Perregaard.   Lift and project for mixed 0-1 programming: Recent progress.   Discrete Applied Mathematics , 123(1-3):129–154, 2002. [12] E. Balas and M. Perregaard. A precise correspondence between lift-and-project cuts, simple disjunctive cuts, and mixed integer Gomory cuts for 0-1 program- ming.   Math. Program. , 94(2-3, Ser. B):221–245, 2003. The Aussois 2000 Work- shop in Combinatorial Optimization. 37
[13] E. Balas and A. Saxena. Optimizing over the split closure.   Mathematical Pro- gramming A , 113:219–240, 2008. [14] E. Balas and E. Zemel. Facets of the knapsack polytope from minimal covers.  SIAM Journal on Applied Mathematics , 34:119–148, 1978. [15] R.E. Bixby, S. Ceria, C.M. McZeal., and M.W.P Savelsbergh. Miplib 3.0, 1998.  http://www.caam.rice.edu/ ∼ bixby/miplib/miplib.html . [16] R.E. Bixby, M. Fenelon, Z. Gu, E. Rothberg, and R. Wunderling.   The Sharpest Cut , chapter Mixed-Integer Programming: A Progress Report, pages 309–326. MPS-SIAM Series on Optimization. SIAM, 2004. [17] P. Bonami and E. Balas. Cgllandp,   https://projects.coin-or.org/cgl/wiki/cgllandp , July 2006. [18] P. Bonami, G. Cornu ́ ejols, S. Dash, M. Fischetti, and A. Lodi.   Projected Chv ́ atal-Gomory cuts for mixed integer linear programs.   Mathematical Pro- gramming, Series A , 113(2):241–257, 2008. [19] P. Bonami and M. Minoux.   Using rank-1 lift-and-project closures to gener- ate cuts for 0–1 MIPs, a computational investigation.   Discrete Optimization , 2(4):288–307, 2005. [20] A. Caprara and A. N. Letchford.   On the separation of split cuts and related inequalities.   Mathematical Programming , 94(2-3):279–294, 2003. [21] V. Chv ́ atal. Edmonds polytopes and a hierarchy of combinatorial optimization.  Discrete Mathematics , 4:305–337, 1973. [22] W. Cook, R. Kannan, and A. Schrijver.   Chv ́ atal closures for mixed integer programming problems.   Mathematical Programming , 47:155–174, 1990. [23] G. Cornu ́ ejols and Y. Li. Elementary closures for integer programs.   Operations Research Letters , 28:1–8, 2001. [24] G. Cornu ́ ejols and G. Nannicini.   Reduce-and-split revisited: Efficient genera- tion of split cuts for mixed-integer linear programs. Technical report, Carnegie Mellon University, July 2010. Available at http://integer.tepper.cmu.edu. [25] S. Dash and M. Goycoolea.   A heuristic to generate rank-1 gmi cuts.   IBM Research Report RC24874, IBM Research, October 2009. 38
[26] S. Dash, O. G ̈ unl ̈ uk, and A. Lodi. MIR closures of polyhedral sets.   Mathematical Programming , 121(1):33–60, 2010. [27] F. Eisenbrand.   On the membership problem for the elementary closure of a polyhedron.   Combinatorica , 19(2), 1999. [28] M. Fischetti and A. Lodi. Optimizing over the first Chv ́ atal closure.   Mathemat- ical Programming , 110:3–20, 2007. 10.1007/s10107-006-0054-8. [29] M. Fischetti, A. Lodi, and A. Tramontani. On the separation of disjunctive cuts.  Mathematical Programming , 2009. In press, available online, doi 10.1007/s10107- 009-0300-y. [30] M. Fischetti and D. Salvagnin. An in-out approach to disjunctive optimization. In Andrea Lodi, Michela Milano, and Paolo Toth, editors,   CPAIOR , volume 6140 of   Lecture Notes in Computer Science , pages 136–140. Springer Berlin / Heidelberg, 2010. [31] Matteo Fischetti and Domenico Salvagnin. A relax-and-cut framework for go- mory’s mixed-integer cuts.   In Andrea Lodi, Michela Milano, and Paolo Toth, editors,   CPAIOR , volume 6140 of   Lecture Notes in Computer Science , pages 123–135. Springer, 2010. [32] J. Forrest. CLP, 2004. Available from   http://www.coin-or.org/ . [33] R. E. Gomory.   Solving linear programming problems in integers.   In R. Bell- man and M. Hall, editors,   Combinatorial Analysis, Proceedings of Symposia in Applied Mathematics 10 , pages 211–216, Providence, RI, 1960. [34] R. E. Gomory.   An algorithm for integer solution solutions to linear program- ming. In R. L. Graves and P. Wolfe, editors,   Recent Advances in Mathematical Programming , pages 269–302. McGraw-Hill, 1963. [35] J. E. Kelley. The cutting plane method for solving convex programs.   Journal of SIAM , 8(4):703–712, 1960. [36] R. Lougee-Heimer.   The common optimization interface for operations re- search.   IBM Journal of Research and Development , 47:57–66, January 2003.  http://www.coin-or.org . [37] A. Martin, T. Achterberg, and T. Koch.   MIPLIB 2003, 2003.   Avaiable from  http://miplib.zib.de . 39
[38] G. L. Nemhauser and L. A. Wolsey.   A recursive procedure for generating all cuts for 0-1 mixed integer programs.   Math. Programming , 1990. [39] M. Padberg, T. J. Van Roy, and L. Wolsey. Valid linear inequalities for fixed charge problems.   Operations Research , 33:842–861, 1985. [40] T. Van Roy and L. Wolsey. Solving mixed integer programming problems using automatic reformulation.   Operations Research , 35:45–57, 1987. 40