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′Tx
s.t.
A′x ≥b,
x ∈Zp
+ × Rn−p
+
,
(MILP)
∗Supported by ANR grant ANR06-BLAN-0375
1
where A′ is an m × n rational matrix, c′ ∈Qn and b ∈Qm.
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′Tx
s.t.
A′x ≥b,
x ∈Rn
+.
(LP)
We also consider the standard form of (LP) where slack variables are introduced:
max cTx
s.t.
Ax = b,
x ∈Rn+m
+
.
(SLP)
In (SLP), we assume that the slack variables are the first m ones (x1, . . . , xm) and
the structural variables are the last n (xm+1, . . . , xm+n). With this ordering of the
variables A = (−I A′) (where I is the identity matrix) and cT = (0T, c′T).
We
denote by N := {m+1, . . . , m+n} the index set of structural variables in (SLP), by
NI := {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 xJ the vector with component in J and by AJ the
sub-matrix of A composed by the columns i ∈J (A′ = AN). Given J ⊆M, we
denote by AJ 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 Aj and Ai respectively.
We denote the index set of variables in a basis of LP by B := {i1, . . . , im} ⊆
{1, . . . , n + m} and the index set of nonbasic variables by J := {1, . . . , n + m} \ B.
Given the index set of a basis B; AB is the basis matrix (we recall that variables in-
dexed by B form a basis whenever AB is non-singular), the LP tableau corresponding
to B is given by
xB = AB−1b −AB−1AJxJ.
Finally, we denote A = AB−1A and b = AB−1b.
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 A1x ≥b1 ∨A2x ≥b2 ∨. . . ∨
Aqx ≥bq 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) ∈Zn+1 is
such that π{p+1,...,n} = 0 the split disjunction πTx ≤π0 ∨πTx ≥π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 ∈Rn
+ : A′x ≥b, πTx ≤π0
	
∪

x ∈Rn
+ : A′x ≥b, πTx ≥π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 ik ∈B ∩NI be such
that bk ̸∈Z. The row of the simplex tableau corresponding to ik is
xik +
X
j∈J
akjxj = bk
(1)
Let f0 = bk −⌊bk⌋. The intersection cut [3] from the convex set {x ∈Rn+m : ⌊bk⌋≤
xik ≤⌈bk⌉} applied to (1) is
X
j∈J
max {akj(1 −f0), −akjf0} xj ≥f0(1 −f0)
(2)
This cut is valid for all solution to (MILP) and is also known as the simple disjunctive
cut from the condition xik ≤⌊bk⌋∨xik ≥⌈bk⌉.
Gomory Mixed Integer Cut
The simple intersection cut can be strengthened
using the integrity of the variables in J ∩NI.
For each j ∈J ∩NI we define
fj := akj −⌊akj⌋. We define π ∈Zm+n as
πj :=









⌊akj⌋
if j ∈J ∩NI and fj ≤f0,
⌈akj⌉
if j ∈J ∩NI and fj > f0
1
if j = ik,
0
otherwise.
5
The Gomory Mixed-Integer Cut is the intersection cut from the convex set {x ∈
Rn+m : ⌊bk⌋≤πTx ≤⌈bk⌉} applied to (1):
X
j∈J∩NI
fj≤f0
fj(1−f0)xj+
X
j∈J∩NI
fj>f0
(1−fj)f0xj+
X
j∈J\NI
max {akj(1 −f0), −akjf0} xj ≥f0(1−f0)
(3)
We note that the GMI cut dominates all intersection cuts obtained from row (1)
and convex sets of the form {x ∈Rn+m : ⌊bk⌋≤πTx ≤⌈bk⌉} with π(J\NI)∪(B\{ik}) = 0
and πik = 1 (see [1] for a proof).
The lift-and-project cut
The lift-and-project cuts are the valid inequalities for
the sets P (ek,π0) taken for any k = 1, . . . , p and π0 ∈Z, obtained by intersecting the
polyhedron {x ∈Rn
+ : A′x ≥b} with a simple disjunction of the form xk ≤π0 ∨xk ≥
π0 + 1.
The fundamental theorem of Balas [5, 4] on unions of polyhedra allows to formu-
late the separation problem for P (ek,π0) as a linear program.
Theorem 1 ([5, 7]). Let ˆx ∈Rn
+. ˆx ∈P (π,π0) if and only if the solution to the Cut
Generation LP
min αT ˆx −β
s.t. :
α = uTAN + s −u0π,
α = vTAN + t + v0π,
β = uTb −u0π0,
β = vTb + v0(π0 + 1),
α ∈Rn, β ∈R, u, v ∈Rm
+, s, t ∈Rn
+, u0, v0 ∈R+,
is non-negative.
If the solution the cut generation linear program is negative, αTx ≥β defines a
valid inequality in the space of structural variables that cuts offthe point ˆx.
Lift-and-project cuts are separated by solving the cut generation linear program
for simple disjunctive (i.e. with π = ek). 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 P
i∈M(ui +
vi) + P
i∈N(si + ti) + u0 + v0 = 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, ˆu0, ˆv0) to (CGLP), the coefficients ˆα ver-
ify:
ˆαk = max{ˆuAk −ˆu0, ˆvAk + ˆv0}
and
ˆαj = max{ˆuAj, ˆvAj}, j ̸= k
These coefficients can be strengthened by replacing ˆαj, for j ∈{1, . . . , p} \ {k},
with
αj := min{ˆuAj −ˆu0⌊mj⌋, ˆvAj + ˆv0⌈mj⌉}
where
mj := ˆuAj −ˆvAj
ˆu0 + ˆv0
,
(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 Pe. Geometrically, It is obtained by
intersecting all polyhedra P (ek,π0) for all k ∈{1, . . . , p} and all π0 ∈Z:
Pe :=
\
k∈{1,...,p}
π0∈Z
P (ek,π0)
Equivalently, Pe 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 ̸∈B:
P(B) := {x ∈Rn+m : xB = b −A
JxJ, xJ ≥0}.
The simple lift-and-project closure can be defined alternatively as
Pe = projN
 \
B∈B
\
k∈NI∩B
conv
P (B) ∩

x ∈Rn+m : xm+k ≤⌊bk⌋∨xm+k ≤⌈bk⌉
	

!
.
(where projN 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 Pe∗. It
is more difficult to give a precise and intuitive geometrical definition of it than for
Pe. By using the equivalence between lift-and-project cuts and GMI cuts, Pe∗is also
obtained by taking all GMI cuts defined from all bases of (SLP). More formally, for
each basis B ∈B and k ∈NI ∩B, let ΠB
k := {(π, π0) ∈Zn+1 : πk = 1, πN\NI∪B\{k} =
0, π0 = ⌊bk⌋}. Π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:
Pe∗:= projN

\
B∈B
\
k∈NI∩B
\
(π,π0)∈ΠB
k
conv
P (B) ∩

x ∈Rn+m : πTx ≤π0 ∨πTx ≥π0 + 1
	


.
Since both Pe and Pe∗are defined by a finite number of inequalities both are
clearly polyhedra. Moreover, Pe can be optimized in polynomial time. To the best
of our knowledge, it is not known if Pe∗can be optimized in polynomial time.
8
Finally, let us remind that the split closure PS is obtained by intersecting all split
cuts:
PS :=
\
(π,π0)∈Zn×Z
π{p+1,...,n}=0
P (π,π0).
As shown by [22], PS is a polyhedron. Andersen, Cornu´ejols and Li [2] have shown
that PS can also be defined in terms of intersection cuts:
PS = projN




\
B∈B
\
(π,π0)∈Zn×Z
π{p+1,...,n}=0
conv
P (B) ∩

x ∈Rn+m : πTx ≤π0 ∨πTx ≥π0 + 1
	




.
From the definitions, it should be clear that PS ⊆Pe∗⊆Pe∗, since Pe∗and Pe only
use a subset of splits and elementary disjunctions belong to ΠB
k . It is NP-Hard to
optimize over PS. 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 PS often takes more time than solving MILP to optimality). This
justifies our motivation to optimize Pe∗and Pe.
3
The membership LP
In this section, we establish a linear program which given a split disjunction (π, π0)
and a point ˆx ∈Rn 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 π = ek), 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 ∈Rn
+ : A′x ≥b}, ˆx ∈P and (π0, π) ∈Zn+1 be such that
π0 < πT ˆx < π0 + 1. ˆx ∈conv
P ∩

πTx ≤π0
	
∪

πTx ≥π0 + 1
	


if and only if
there exists y ∈Rn such that
πTy −(π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 x0 ∈
P ∩

πTx ≤π0
	
, x1 ∈P ∩

πTx ≥π0 + 1
	
and λ ∈]0, 1[ such that ˆx = λx1+(1−
λ)x0. Without loss of generality, we can assume that πTx0 = π0, πTx1 = π0+1.
Then, since πT(λx1 + (1 −λ)x0) = πT ˆx, we have
λ = πT ˆx −π0.
We take y = λx1 and verify that it satisfies (4).
First, πTy−(π0 +1)(πT ˆx−π0) = λ(π0 +1)−(π0 +1)λ = 0. Also, Ay −b(πT ˆx−
π0) = (Ax1 −b) λ ≥0 and y = λx1 ≥0, since Ax1 ≥b , x1 ≥0 and λ ≥0.
Furthermore, since ˆx = y + (1 −λ)x0 we have:
Ay −λb + (1 −λ)(Ax0 −b) = Aˆx −b.
and therefore, since Ax0 −b ≥0 and λ ≤1
Ay −λ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 x1 = y
λ and x0 = ˆx−y
1−λ. Clearly ˆx = λx1 + (1 −λ)x0.
Furthermore x1 ∈P and πTx1 ≥π0 + 1.
It remains to show that x0 ∈P ∩{πT x ≤π0}. x0 ∈P, since (1−λ)(Ax0 −b) =
A(ˆx −y) −b + bλ = Aˆx −b −Ay + bλ ≥0 and (1 −λ)x0 = ˆx −y ≥0. Finally
πTx0−π0 = πT ˆx −πTy −(1 −λ)π0
1 −λ
= −πT y + λ + λπ0
1 −λ
= −πTy −(π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 πTy −(π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 u0 + v0 = 1:
min αT ˆx −β
s.t.:
α = uTA′ + s −u0π,
α = vTA′ + t + v0π,
β = uTb −π0u0,
β = vTb + (π0 + 1)v0,
u0 + v0 = 1,
u, v ∈Rm
+, s, t ∈Rn
+, u0, v0 ∈R+
(CGLP’)
A basic results stated in [12] (Lemma 1) is that in any solution of (CGLP) that yields
an inequality αTx ≥β that is not dominated by the constraint of (LP), both u0 and
v0 are positive. The following lemma shows that in fact, if we assume ˆx ∈P and
π0 < πT ˆx < π0 + 1, the conditions u0, v0 ≥0 can be dropped from (CGLP’).
Lemma 3. Let ˆx ∈P be such that π0 < πT ˆx < π0+1. Suppose that (α, β, u, v, u0, v0)
verifies the following system of equations:
α = uTA′ + s −u0π,
α = vTA′ + t + v0π,
β = uTb −π0u0,
β = vTb + (π0 + 1)v0,
u0 + v0 = 1,
u, v ∈Rm
+, s, t ∈Rn
+, u0, v0 ∈R
with u0 ≤0 or v0 ≤0. Then αT ˆx ≥β.
Proof. The proof if similar for u0 ≤0 and v0 ≤0; we only consider the case u0 ≤0.
Let (α, β, u, v, u0, v0) be a vector that satisfies the conditions of the statement.
Then, by definition of (α, β, u, v, u0, v0)
αT ˆx −β = (uTA′ + s −u0π)ˆx −uTb + π0u0 = uT(A′ˆx −b) −u0(πT ˆx −π0).
Now the last quantity is non-negative since u ≥0, A′ˆx−b, πT ˆx > π0 and u0 ≤0.
11
Since we are only interested in negative solutions to (CGLP’), by application of
the lemma, we can therefore remove the conditions u0, v0 ≥0.
After removing non-negativity constraints on u0 and v0, we can eliminate α, β
and v0 from (CGLP’):
min(uTA′)ˆx + (s −u0π)T ˆx −uTb −π0u0,
s.t.:
(u −v)TA′ + (s −t) = π
(v −u)Tb −u0 = −π0 −1
u, v ∈Rm
+, s, t ∈Rn
+, u0 ∈R
Finally we eliminate u0:
min uT(Aˆx −b) + sT ˆx + (πT ˆx −π0)
(u −v)Tb −π0 −1


,
s.t.:
(u −v)TA + (s −t) = π
u, v ∈Rm
+, s, t ∈Rn
+.
(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 u0 and v0 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 π = ek and π0 = 1, the solution u = v = 0, t = 0, s = ek defines the in-
equality xk ≤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 u0 + v0 = 1 is that
if ˆx is an extreme point of P such that 0 < ˆxk −π0 < 1 then an optimal solution
to (CGLP’) with π = ek 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 ∈Rn
+ : Ax ≥b}, and ˆx be an extreme point of P such
that 0 < πT ˆx −π0 < 1, then the unique solution to
max πTy −(π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 πTy −(π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=(πTx −π0) = 0
y= = 0.
This system in turn has a unique solution.
Finally, it is trivial to check that πTy −(π0 + 1)(πˆx −π0) < 0:
πTy −(π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 xk ≤π0 ∨xk ≥π0 + 1. Note that this assumption is not restrictive since
any split πTx ≤π0 ∨πTx ≥π0 + 1 can always be put into this form by defining a
new variable to be equal to πTx. For this elementary disjunction, the membership
LP is
max yk −⌈ˆxk⌉(ˆxk −⌊ˆxk⌋),
s.t.:
0 ≤A′y −b(ˆxk −⌊ˆxk⌋) ≤A′ˆx −b,
0 ≤y ≤ˆx,
y ∈Rn.
(MLP’k)
For ease of notation, in the sequel, we denote (ˆxk −⌊ˆxk⌋) by fk.
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 uT(A′ˆx −b) + sT ˆx + (u −v)Tbfk −⌈ˆxk⌉fk
s.t.:
(u −v)TA + (s −t) = ek
u, v ∈Rm
+, s, t ∈Rn
+.
(CGLP’k)
A solution (u, v, s, t) to (CGLP’k) defines a cut of the form:
uTA′x + sTx +

(u −v)T b −⌈ˆxk⌉

xk ≥uTb +

(u −v)T b −⌈ˆxk⌉

⌊ˆxk⌋
(7)
in the space of structural variables.
Finally, (MLP’k) in standard form is
max ym+k −⌈ˆxk⌉fk
s.t.:
Ay = A′ˆx −b + bfk,
0 ≤yN ≤ˆxN,
0 ≤yM ≤A′ˆxN −b,
y ∈Rn + m.
(SMLPk)
(SMLPk) 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 (SMLPk) 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 (SMLPk), is that all of its bases are bases of (SLP).
Proposition 6. The variables indexed by B form a base of (SMLPk) 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 (SMLPk) and to relate them to intersection cuts for (SLP). First,
in the next lemma, we characterize the dual feasible bases of (SMLPk).
15
Lemma 7. Let B = {i1, . . . , im} be the index set of a basis of (SMLPk). B is dual
feasible if either:
(i) the variable ym+k is non-basic at its upper bound, or
(ii) ym+k is basic with corresponding tableau row ym+k+P
j∈J aijyj = ai0 in (SMLPk)
and j ∈J is non-basic at its upper bound if aij < 0 and nonbasic at its lower
bound if aij > 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 ̸∈B then cB = 0, therefore all variables
have a zero reduced cost except xm+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 xm+k is basic in row i. The
reduced cost of a variable j ∈J is given by cj = cj −cBAB−1Aj = 0−aij. Therefore,
B is dual feasible if for all j ∈J such that aij > 0, j ∈J−and for all j ∈J such
that aij < 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 (SMLPk), we need to take particular care in denoting the right-hand-sides
of the two associated LP tableau’s. We will denote by b := AB−1b, the right hand
side in the tableau of (SLP) and by a0 := AB−1(A′ˆx −bfk) the right hand side in
the tableau of (SMLPk).
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 ym+k is non-basic, all dual variables have value 0
except sk which is equal to 1. In that case, the dual objective value of the solution
is alway non-negative:
ˆxk −⌈ˆxk⌉(ˆxk −⌊ˆxk⌋) = ⌊ˆxk⌋(⌈ˆxk⌉−ˆxk) ≥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 ym+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:
uj =
(
−aij
if j ∈J+ ∩M,
0
if j ∈M \ J+
(8)
vj =
(
aij
if j ∈J−∩M
0
if j ∈M \ J−
(9)
sj =
(
−aij
if j ∈J+ ∩N,
0
if j ∈N \ J+
(10)
tj =
(
aij
if j ∈J−∩N
0
if j ∈N \ J−
(11)
In the following, we will denote by x ∈Rn+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 xm+k ∈]⌊ˆxk⌋, ⌈ˆxk⌉[.
Lemma 8. Let B be the index set of a dual feasible basis of (SMLPk) such that
m + k ∈B. Let x ∈Rn+m be the primal basic solution of (SLP) corresponding to
basis B. Suppose that xm+k ̸∈]⌊ˆxk⌋, ⌈ˆxk⌉[, then ˆx is not cut by the dual solution to
(SMLPk).
Proof. By Lemma 3 the dual solution gives a cut for ˆx only if u0 and v0 are positive.
u0 is given by u0 = (u−v)Tb+⌈ˆxm+k⌉. Note that (u−v)T b = −P
i∈M aijb = −xm+k.
Therefore u0 > 0 only if xm+k < ⌈ˆxm+k⌉. Similarly since v0 = 1 −u0, v0 > 0 only if
xm+k > ⌊ˆxk⌋.
Lemma 8 indicates that the only relevant dual feasible bases for valid cutting
planes are those where xk ∈]⌊ˆxk⌋, ⌈ˆxk⌉[. 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 xm+k reads
xm+k +
X
j∈J
aijxj = bi
Theorem 9. Let B be the index set of a dual feasible basis of (SMLPk) such that
m + k ∈B. Let x ∈Rn+m be the primal basic solution of (SLP) corresponding to
this basis. If xm+k ∈]⌊ˆxk⌋, ⌈ˆxk⌉[, the cut obtained from the dual solution of (SMLPk)
corresponding to the basis indexed by B is equivalent to the simple intersection cut
for xk 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.
uTA′xN + sTxN +

(u −v)T b −⌈ˆxk⌉

xm+k ≥uTb +

(u −v)T b −⌈ˆxk⌉

⌊xk⌋.
We start by replacing A′xN −b with xM:
uTxM + sTxN +

(u −v)T b −⌈ˆxk⌉

xm+k ≥

(u −v)T b −⌈ˆxk⌉

⌊xk⌋.
Using the values of u and s given by (8) and (10) this can be rewritten as:
−
X
j∈J+
aijxj +

(u −v)T b −⌈ˆxk⌉

xm+k ≥

(u −v)T b −⌈ˆxk⌉

⌊xk⌋.
Noting that (u −v)Tb = (AB−1b)i = bi the cut can be rewritten as:
−
X
j∈J+
aijxj +
bi −⌈ˆxk⌉


xm+k ≥
bi −⌈ˆxk⌉


⌊xk⌋.
Now using the tableau row of (SLP) xm+k + P
j∈J aijxj = bi, we eliminate xm+k:
−
X
j∈J+
aijxj +
bi −⌈ˆxk⌉


(bi −
X
j∈J
aijxj) ≥
bi −⌈ˆxk⌉


⌊xk⌋.
Finally, re-grouping the coefficient, we obtain:
−(bi −⌊ˆxk⌋)
X
j∈J+
aijxj + (⌈ˆxk⌉−bi)
X
j∈J−
aijxj ≥(bi −⌊ˆxk⌋)(⌈ˆxk⌉−bi).
(12)
Since bi = xm+k ∈]⌊ˆxk⌋, ⌈ˆxk⌉[, we have bi −⌊ˆxk⌋= bi −⌊bi⌋, defining f0 :=
bi −⌊bi⌋= xm+k −⌊xm+k⌋as in (2), we have that (12) is equivalent to
−f0
X
j∈J+
aijxj + (1 −f0)
X
j∈J−
aijxj ≥(1 −f0)f 0.
(13)
This last cut is identical to the intersection cut (2). Indeed, if j ∈J+, aij ≤0
implies that max{−f0aij, (1 −f0)aij} = −f0aij; and if j ∈J−, aij ≥0 implies that
max{−f0aij, (1 −f0)aij} = (1 −f0)aij. 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 u0 = (u −v)TA + π0 + 1, v0 = 1 −u0,
α = uTA + s −u0ek and β = uTb. 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 (SMLPk) such that
m + k ∈B. Let x ∈Rn+m be the primal basic solution of (SLP) corresponding to
basis B. If xm+k ∈]⌊ˆxk⌋, ⌈ˆxk⌉[, the strengthened lift-and-project cut obtained from the
dual solution of (SMLPk) 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{uTAj, vTAj} with αj for j = 1, . . . , p, j ̸= k
where αj is given by
αj := min{uAj −u0⌊mj⌋, vAj + v0⌈mj⌉}
where u, v, u0 and v0 are feasible for (CGLP) and
mj := uAj −vAj
u0 + v0
Therefore to obtain the strengthened cut, we need to add αj −ˆαj to the coefficient of
xj obtained in (13) for j = 1, . . . , p, j ̸= 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). u0 is
then given by u0 = (u −v)TA + π0 + 1 = π0 + 1 −ˆxm+k = 1 −f0 (where, as before
f0 = ˆxm+k −⌊xm+k⌋) and v0 = 1 −u0 = f0.
Using the definition of (CGLP’k), we can rewrite mj as mj = (tj −sj). From
this, it is immediate that for j ∈B, since sj = tj = 0, mj = 0. Furthermore, from
the constraints of (CGLP’k) we then have (u −v)TAj = 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 ∩NI. In this case, using the value of the dual solution
given by (8)–(11), we have mj = (tj −sj) = aij Summing up everything, so far, we
have that the formula for ˆαj for j ∈{1, . . . , p} \ B is given by
αj = min{uAj −(1 −f0)⌊aij⌋, vAj + f0⌈aij⌉}.
To establish the strengthened coefficients, we consider separately the case j ∈J+
and the case j ∈J−.
First, assume j ∈J+ ∩NI.
Then aij ≤0, sj = −aij and tj = 0.
From
(v −u)TAj = (sj −tj) = −aij ≥0, we have ˆαj = vAj and uAj = vAj + aij therefore:
αj −ˆαj = min

vAj + aij −(1 −f0) ⌊aij⌋, vAj + f0 ⌈aij⌉
	
−vAj =
min {aij −(1 −f0) ⌊aij⌋, f0 ⌈aij⌉} .
Since j ∈J+, the coefficient for xj in (13) is −f0aij, the new coefficient is therefore:
−f0aij + min {aij −(1 −f0) ⌊aij⌋, f0 ⌈aij⌉}
= min {−f0aij + aij −(1 −f0) ⌊aij⌋, −f0aij + f0 ⌈aij⌉}
= min {(1 −f0) (aij −⌊aij⌋) , f0 (⌈aij⌉−aij)}
Now, we consider the case j ∈J−∩NI. Then aij ≥0, sj = 0 and tj = aij. From
(v −u)TAj = (sj −tj) = −aij ≤0, we have ˆαj = uAj and vAj = uAj −aij therefore:
αj −ˆαj = min

uAj −(1 −f0) ⌊aij⌋, uAj −aij + f0 ⌈aij⌉
	
−uAj =
min {−(1 −f0) ⌊aij⌋, −aij + f0 ⌈aij⌉} .
Since j ∈J−, the coefficient for xj in (13) is (1 −f0)aij, the new coefficient is
therefore:
(1 −f0) aij + min {−(1 −f0) ⌊aij⌋, −aij + f0 ⌈aij⌉}
= min {(1 −f0) aij −(1 −f0) ⌊aij⌋, (1 −f0) aij −aij + f0 ⌈aij⌉}
= min {(1 −f0) (aij −⌊aij⌋) , f0 (⌈aij⌉−aij)} .
Therefore, for both j ∈J+ ∩NI and j ∈J−∩NI we have that the coefficient for
the strengthened cut is
min {(1 −f0) (aij −⌊aij⌋) , f0 (⌈aij⌉−aij)} .
(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 u0+v0 = 1 is used here whereas the normalization condition
P(ui+vi)+P(si+ti)+u0+v0 = 1 was used in [12]. In [6], the theorems of [12] were
generalized to weighted normalizations of the form P ψi(ui+vi)+P ξi(si+ti)+u0+
v0 = ψ0 where ψ ∈Rm
+ , ξ ∈Rn
+ 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 u0 +v0 = 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 Pe and approximating Pe∗
We now turn back to our initial goal which is the optimization of Pe and Pe∗. 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 ̸∈Z have non-negative
objective value, we have a proof that x∗∈Pe.
To approximate Pe∗, 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 Pe∗there is
no guarantee of how good is the approximation. Nevertheless, it is guaranteed that
approximating Pe∗in this way will give a better bound than optimizing Pe 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 Pe 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∗∈Pe (and stops the
algorithm) but if it only happens for some k’s it only indicates that x∗∈P (ek,⌊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 offis 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 Pe∗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 k1, . . . , kp. 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’ki) to be either primal or dual feasible for
(MLP’ki+1). There is one simple exception to this, if ˆxki = ˆxki+1, both problems
have the same constraint system and therefore the solution of (MLP’ki) is primal
feasible for (MLP’ki+1). We try to benefit from this by solving the problems (MLP’k)
in increasing order of the value ˆxk (also hoping that if ˆxki is close to ˆxki+1, the
solution of (MLP’ki) will be close to being primal feasible for (MLP’ki+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 Pe∗
0.
Initialize feasible region.
C ←{x ∈Rn
+ : A′x ≥b}.
1.
Initialize variables list
K ←{1, . . . , p}, reinit ←true.
2.
Master Problem
Solve max{c′Tx : x ∈C}. Let ˆx be the solution.
3.
Filter variables
F ←{i ∈K : ˆxi −⌊ˆxi⌋≥ǫ}, K ←∅. Sort F by increasing values of ˆxk.
4.
Separate
For each k ∈F solve (MLP’k).
If the solution is ≤−ǫ construct
strengthened cut αTx ≥β from its dual solution and let K ←K ∪{k},
C ←C ∩{x : αTx ≥β}.
5.
Termination
If K = ∅and reinit = true, then STOP.
6.
Loop
If K = ∅or tailing offis detected, then go to 1, else reinit ←false, go
to 2.
6
Computational results
We now present some computational experiments aimed at assessing the interest of
our procedures for optimizing over Pe and approximating Pe∗. 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 Pe∗can be
and how quickly it can be computed. First, we will present computations of Pe and
Pe∗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 Pe∗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 Pe∗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 Pe and Pe∗
We ran our code to compute Pe and approximate Pe∗on 62 MIPLIB 3.0 instances1
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 Pe and approximation of Pe∗
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.
1We 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 Pe or Pe∗
24
Table 1: CPU time and gap closed by Pe and Pe∗on MIPLIB 3.0.
Pe
Pe∗
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 Pe and Pe∗on MIPLIB 3.0.
Pe
Pe∗
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 Pe and Pe∗on MIPLIB 3.0.
Pe
Pe∗
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 Pe and Pe∗for MIPLIB 2003.
Pe
Pe∗
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
Pe
Pe∗
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, Pe 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 Pe∗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 Pe∗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 Pe). Finally, computing times vary a lot between
instances but are usually close between the four methods. In total, for Pe∗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 Pe∗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 Pe. This is not surprising since our stopping criterion is
that the point x∗belongs to Pe and that the cuts generated in Pe∗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 Pe∗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 Pe∗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 Pe and Pe∗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 Pe∗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 Pe∗.
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
Pe
8.08
47.12
Pe∗
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 Pe and Pe∗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 Pe and Pe∗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 Pe∗. After 100 rounds of GMI it is only slightly higher than the gap closed by Pe.
The gap closed by lift-and-project cuts after 10 and 50 rounds is significantly bigger
than with GMI cuts and with Pe but it is still smaller than with Pe∗, while the CPU
time becomes bigger for 50 rounds. Due to the tailing offeffect 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 Pe∗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 Pe∗. 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 Pe∗
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, Pe∗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, Pe∗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
Pe∗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
Pe∗
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.
1timings on different machines
32
6.4
Branch-and-cut computations
The experiments reported in the last three subsections show that our approach based
on Pe∗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 Pe∗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 Pe∗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+Pe∗. 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+Pe∗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+Pe∗,
nsrand-ipx is solved by CPLEX+Pe∗but not by CPLEX-BAC. For CPLEX+Pe∗, we test
two time limits for the Pe∗procedure a short time limit of 10 seconds (denoted
CPLEX+Pe∗-10), and a long one of 1800 seconds (denoted CPLEX+Pe∗-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+Pe∗–10 and 5 times bigger for CPLEX+Pe∗–1800. For instances in set C,
the gap closed after 3 hours is on average smaller with CPLEX+Pe∗–10. The results
in terms of number of nodes are not as grim. The node reduction is limited with
CPLEX+Pe∗–10, but with CPLEX+Pe∗–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+Pe∗
85.9
0.39
41.04
0
Instances in set B
CPLEX-BAC
32.4
46.64
11723
0
CPLEX+Pe∗–10
46.0
93.85
10414
0
CPLEX+Pe∗–1800
58.8
238.15
5461.31
0
danoint
CPLEX-BAC
2.92
7993
1119303
0
CPLEX+Pe∗–10
3.68
> 10800
> 585297
44.9
CPLEX+Pe∗–1800
5.8
> 10800
> 188971
32.6
nsrand-ipx
CPLEX-BAC
50.03
> 10800
>849402
84
CPLEX+Pe∗–10
76.8
3449
220105
0
CPLEX+Pe∗–1800
79.8
892.74
52780
0
Instances in set C
CPLEX-BAC
23.2
> 10800
> 31339
45.5
CPLEX+Pe∗–10
24.7
> 10800
> 19066
42.7
CPLEX+Pe∗–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 Pe∗. 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 Pe 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 Pe 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 Pe∗. 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
Pe∗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 Pe∗. 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 Pe∗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