This item was downloaded from IRIS Università di Bologna (https://cris.unibo.it/)
When citing, please refer to the published version.
This is the final peer-reviewed accepted manuscript of:
Matteo Fischetti, Ivana Ljubić, Michele Monaci, Markus Sinnl (2017) A New General-Purpose Algorithm for Mixed-IntegerBilevel Linear Programs. Operations Research 65(6):1615-1637.
The final published version is available online at: https://doi.org/10.1287/opre.2017.1650
Rights / License:
The terms and conditions for the reuse of this version of the manuscript are specified in the publishing policy. For all terms of use and more information see the publisher's website.
Submitted to Operations Researchmanuscript OPRE-2016-07-379.R3
A new general-purpose algorithm formixed-integer bilevel linear programs
Matteo FischettiDEI, University of Padua, Italy. [email protected]
Ivana LjubicESSEC Business School of Paris, France. [email protected]
Michele MonaciDEI, University of Bologna, Italy. [email protected]
Markus SinnlISOR, University of Vienna, Austria. [email protected]
Bilevel optimization problems are very challenging optimization models arising in many important prac-
tical contexts, including pricing mechanisms in the energy sector, airline and telecommunication industry,
transportation networks, critical infrastructure defense, and machine learning. In this paper, we consider
bilevel programs with continuous and discrete variables at both levels, with linear objectives and constraints
(continuous upper level variables, if any, must not appear in the lower level problem). We propose a gen-
eral purpose branch-and-cut exact solution method based on several new classes of valid inequalities, which
also exploits a very effective bilevel-specific preprocessing procedure. An extensive computational study is
presented to evaluate the performance of various solution methods on a common testbed of more than 800
instances from the literature and 60 randomly generated instances. Our new algorithm consistently outper-
forms (often by a large margin) alternative state-of-the-art methods from the literature, including methods
exploiting problem-specific information for special instance classes. In particular, it solves to optimality more
than 300 previously unsolved instances from the literature. To foster research on this challenging topic, our
solver is made publicly available online.
Key words : bilevel optimization, mixed-integer programming, cutting planes, intersection cuts,
branch-and-cut, computational analysis
History :
1
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs2 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
1. Introduction
In many real-world applications, a serious limitation of the standard optimization models is due to
the assumption that decisions are made by a single decision maker. A large variety of applications
involves multiple decision makers that act in a competitive environment, with different and quite
often conflicting objectives. Hierarchical optimization allows to model optimization problems with
multiple decision makers, whose decisions are made in a sequential (hierarchical) fashion: each
decision at a certain level in this hierarchy affects the decisions made at the lower levels, but also
the pay-offs for the decisions made at the higher levels.
In this article, we deal with bilevel optimization problems with two decision makers, commonly
denoted as the leader and the follower : in these problems, first the leader makes a decision, and
then the follower optimizes its objective, affected by the decisions of the leader. It is assumed that
the leader can anticipate the decisions of the follower, hence the leader optimization task is a nested
optimization problem that takes into consideration the follower’s response. Bilevel optimization
problems, together with their generalization to multilevel optimization, play a fundamental role in
many real-life applications, when competitive agents operate in a hierarchical way with conflicting
objectives. As such, they can be interpreted as static Stackelberg games, and find applications in
many economic models. For example, it is well known that bilevel optimization is an inevitable tool
for modeling pricing mechanisms in the energy sector (Zugno et al. 2013), airline and telecommu-
nication industry (Brotcorne et al. 2008), or in transportation networks (Gilbert et al. 2015, Labbe
et al. 1998). Similarly, bilevel optimization is the model of choice for capacity planning decisions
made in a competitive environment; see, e.g., Garcia-Herreros et al. (2016) for an optimal expan-
sion of gas networks. Infrastructure planning that takes into consideration deliberate disruptions
(due to sabotage or terrorist attacks) is another important example of bilevel optimization (Brown
et al. 2006, Scaparra and Church 2008, Wood 2010). Recently, bilevel optimization has been used
even in machine learning applications, see Kunisch and Pock (2013).
Despite this increasing interest for bilevel optimization and the fact that the seminal formulation
of bilevel programs dates back to the 70’s (Bracken and McGill 1973), implementation of generic
bilevel optimization solvers has only started in recent years. This can be explained by the inherent
complexity of the bilevel optimization, which is known to be NP-hard even when both leader and
follower problems are linear programs (Jeroslow 1985). In the present article we propose a novel
generic solver that covers a large family of bilevel optimization problems in which decisions of both,
the leader and the follower, are modeled as mixed-integer linear programs. In the computational
evaluation of our method, we consider various classes of instances both from literature and randomly
generated ones. These instances reach from bilevel variants of classical optimization problems such
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 3
as the knapsack problem, the clique problem or the assignment problem, to a problem dealing with
defending a network against malicious virus attacks.
More precisely, in this paper we address a generic Mixed-Integer Bilevel Linear Program
(MIBLP), i.e., a bilevel optimization problem where all objective functions and constraints are
linear, and some/all variables are required to take integer values. Note that MIBLPs are Σ2-hard
(DeNegre 2011, Jeroslow 1985). A MIBLP is defined as follows:
minx,y
cTxx+ cTy y (1)
Gxx+Gyy≤ q (2)
xj integer, ∀j ∈ Jx (3)
y ∈ arg miny′∈Rn2
{dTy′ :Ax+By′ ≤ b, l≤ y′ ≤ u, y′j integer ∀j ∈ Jy} (4)
where x∈Rn1 , y ∈Rn2 , while cx, cy, Gx, Gy, q, d, A, B, b, l and u are given rational matrices/vectors
of appropriate size. Sets
Jx ⊆Nx := {1, · · · , n1} and Jy ⊆Ny := {1, · · · , n2}
identify the (possibly empty) indices of the integer-constrained variables in x and y, respectively.
We will refer to (1) and (2)–(3) as the leader objective function and constraints, respectively, and
to (4) as the follower subproblem. In case the follower subproblem has multiple optimal solutions,
we assume that one with minimum leader cost among those satisfying the leader constraints is
chosen—i.e., we consider the optimistic (or weak) version of bilevel optimization; see, e.g., Loridan
and Morgan (1996).
For the leader, we assume that explicit lower/upper bounds (if any) on the variables x and y are
included in constraints (2). Whenever needed, however, we will refer to this subset of constraints
using notation
x− ≤ x≤ x+ (5)
y− ≤ y≤ y+ (6)
where, as customary, some entries in x+, x−, y−, y− are allowed to be ±∞. As to the follower
subproblem, we assume that the explicit bounds on the y′ variables are given, though some entries
of (l, u) are allowed to be ±∞.
It is well known (Outrata 1990) that MIBLP can conveniently be restated in its value function
formulation as:
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs4 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
minx,y
cTxx+ cTy y (7)
Gxx+Gyy≤ q (8)
Ax+By≤ b (9)
l≤ y≤ u (10)
xj integer, ∀j ∈ Jx (11)
yj integer, ∀j ∈ Jy (12)
dTy≤Φ(x) (13)
where the follower value function for a given x∗ ∈Rn1 is computed by solving the following follower
Mixed-Integer Linear Program (MILP)
Φ(x∗) := miny∈Rn2
{dTy : By≤ b−Ax∗, l≤ y≤ u, yj integer ∀j ∈ Jy}. (14)
Dropping condition (13) from model (7)-(13) leads to the so-called High Point Relaxation (HPR).
The latter one is a Mixed-Integer Linear Program (MILP), whose Linear Programming (LP) relax-
ation will be denoted by HPR.
An HPR solution (x, y) will be called bilevel infeasible if it violates (13). A point (x, y) ∈ Rn,
where n= n1 +n2, will be called bilevel feasible if it satisfies all constraints (8)–(13).
Let Aj be the j-th column of matrix A, and Aij its generic entry. In what follows we will use
notation
JF := {j ∈Nx :Aj 6= 0} (15)
to denote the index set of the leader variables xj (not necessarily integer-constrained) appearing
in the follower problem.
Fischetti et al. (2016b) recently proposed an exact MIBLP solver which is in fact a Branch-and-
Bound (B&B) MILP approach with non-invasive supplements needed to correctly handle bilevel
optimization. An important feature of that work is that the MIBLP solver was built on top of
a stable and powerful MILP solver taking care of all non-bilevel specific issues—including cuts,
heuristics, propagations, numerical stability, effective LP parametrization, multi-threading support,
etc.
In the present work, we considerably extend the results in (Fischetti et al. 2016b) and develop a
more versatile and effective solver for MIBLPs (under proper assumptions on the role of continuous
variables, as reported at the end of the present section). The main novel contributions of the present
paper can be stated as follows.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 5
• A new family of cuts based on formulation (7)-(13) is introduced.
• A new bilevel-specific preprocessing procedure is proposed, and its very significant impact on
the performance of the MIBLP solver is demonstrated.
• New families of Intersection Cuts (ICs) for bilevel programs are presented. ICs were originally
proposed by Balas (1971) for integer programs, and were exploited in the context of bilevel
optimization in (Fischetti et al. 2016b) for the first time. However, in the latter approach,
their application was limited to the cases where Ax+By− b is integer for all HPR solutions
(x, y). Inspired by the recent work of Xu (2012), in the present article we present an additional
class of inequalities that are valid under the assumption above. In addition, we introduce a
new family of “hypercube” ICs that can be applied even when the above assumption does not
hold. For all cuts, sound separation procedures are described.
• A detailed description on how the ICs can be implemented in a numerically stable way is
given.
• A very extensive computational study is reported—different classes of test problems from the
literature are considered, including those proposed by DeNegre and Ralphs (2009), Xu and
Wang (2014b), Tang et al. (2016c) and Fischetti et al. (2016b). Our analysis shows that the
new approach outperforms by a large margin alternative state-of-the-art methods from the
literature—including the most recent ones, namely those proposed in (Xu and Wang 2014b,
Tang et al. 2016c) and Fischetti et al. (2016b).
• The optimal solution values for hundreds of open instances from the recent literature are
provided; see the on-line Appendix (Fischetti et al. 2016a) for details.
• To foster further research on this challenging topic, our solver (along with the benchmark
instances and the accompanying optimal solutions) is made publicly available (Fischetti et al.
2017).
The paper is organized as follows. In Section 2 we review the most relevant approaches to MIBLP
from the literature. Section 3 introduces a family of cutting planes called follower upper bound
cuts along with a new bilevel-specific preprocessing. In Section 4 we derive two new families of
MIBLP intersection cuts. In Section 5 we introduce separation algorithms and their numerically
safe implementation within a Branch-and-Cut (B&C) solver. Section 6 gives some details about
the implementation of our B&C algorithm. The performance of our solver is evaluated in Section
7 by means of computational experiments on a very large set of instances both from the literature
and randomly generated ones, while Section 8 draws some conclusions. Finally, in the Appendix
we sketch the B&B scheme for MIBLPs of Fischetti et al. (2016b).
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs6 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Assumptions It is known that allowing continuous variables in the leader and integer variables
in the follower may lead to bilevel problems whose optimal solutions are unattainable; see, e.g.,
(Moore and Bard 1990, Koppe et al. 2010). As a result, proper assumptions on the role of the
continuous leader variables need to be made to guarantee finite convergence of any solution scheme
when the follower is a MILP (as in our case).
The results given in the present paper are intended to be used within the enumerative scheme
overviewed in the Appendix, whose finite convergence relies on the following
Assumption 1. The continuous leader variables xj (if any) do not appear in the follower problem,
i.e., JF ⊆ Jx.
The above assumption means the continuous leader variables xj’s are in principle allowed, pro-
vided that they are immaterial for the computation of the value function Φ(x). However, as we are
not aware of instances from the literature with continuous xj’s that satisfy Assumption 1, in our
computational experiments we only considered instances where all leader variables are required to
be integer.
Although not strictly required, to simplify our presentation we also require
Assumption 2.
(i) The HPR feasible set is a bounded polyhedron;
(ii) MIBLP has a finite optimal solution;
(iii) the follower MILP (14) has a finite optimal solution for every feasible HPR solution (x∗, ·).
The reader is referred to (Fischetti et al. 2016b, Sect. 3.1) for a treatment of the general case
in which Assumption 2 is not needed, and to Section 3.4 therein for a discussion of alternative
assumptions from the literature.
Finally, the validity of some of our ICs (to be introduced in the forthcoming Subsections 4.1 and
4.2) will require the following:
Assumption 3. Ax+By− b is integer for all HPR solutions (x, y).
Note however that this last assumption is not mandatory, and in fact we present computa-
tional results on instances where Assumption 3 does not hold—namely, those in the XUWANG and
XUWANG-LARGE classes addressed in Subsection 7.1.
2. Literature Overview
Even though there exists a large body of literature devoted to bilevel optimization, there are
relatively few generic bilevel approaches that allow for integer decision variables both in the leader
and in the follower. The first generic branch-and-bound approach to MIBLP was given by Moore
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 7
and Bard (1990). Their algorithm was shown to converge in two cases: either when all leader
variables are integer, or when the follower subproblem is an LP. About 20 years later, building upon
the ideas from Moore and Bard (1990), a MILP-based branch-and-cut algorithm was introduced
by DeNegre and Ralphs (2009), DeNegre (2011). The latter approach, publicly available as MibS
solver (Ralphs 2015), requires that both the leader and the follower are purely integer problems,
as it exploits integer slacks to cut off bilevel-infeasible solutions.
Only very recently, one could observe a growing number of attempts to develop generic bilevel
solvers, but also specialized algorithms that address particular bilevel problem variants. In the fol-
lowing, we summarize these approaches. An iterative MILP approach based on multi-way branching
on the slack variables on the follower constraints has been given by Xu and Wang (2014b), and
another multi-level branching idea has been exploited in the scheme called “the watermelon algo-
rithm” (Xu 2012). Both approaches require the leader variables to be integer, the main difference
being that the former allows the follower to be a MILP, whereas in the latter the follower contains
integer variables only. Another branch-and-cut method that works for integer leader and follower
variables only has been recently proposed by Caramia and Mari (2015).
Solution approaches based on parametric integer programming (PIP) have also been investigated
in the literature, where the follower problem (14) is viewed as a PIP parametrized by x∗. Koppe
et al. (2010) introduced a MIBLP algorithm that, using PIP and binary search, runs in polynomial
time, for fixed dimension of the follower problem. Faısca et al. (2007) proposed an alternative
approach that operates in two steps. First, all follower solutions are enumerated using PIP. Then,
each solution is plugged into the leader, yielding a single-level problem that can easily be solved.
For the special family of zero-sum bilevel problems, i.e., when the leader and the follower share
the same objective but with the opposite signs, three generic solution algorithms have recently been
proposed by Tang et al. (2016c). Their algorithms require leader variables to be binary, whereas
the follower can be a general MILP. Interdiction problems are a special family of zero-sum bilevel
problems in which the leader is given a limited budget to “interdict” the action of the follower. For
interdiction problems, specialized schemes have been developed, see for example, a cutting plane
approach by Wood (2010), and a more recent list of references in (Tang et al. 2016c).
It is also worth mentioning that, to the best of our knowledge, very few solution schemes
(and almost no extensive computational studies) for more general bilevel mixed-integer nonlinear
programs have been proposed so far—see, e.g., the approaches by Gumus and Floudas (2005),
Tsoukalas et al. (2009), Mitsos (2010), Kleniati and Adjiman (2015) and the references therein.
In (Fischetti et al. 2016b), the first branch-and-cut approach for MIBLP that uses intersection
cuts as driving force has been given. Computational results reported in (Fischetti et al. 2016b)
demonstrated that this generic solver significantly outperforms the methods by DeNegre and Ralphs
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs8 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
(2009), DeNegre (2011) and Caramia and Mari (2015). It will be therefore considered in the remain-
der of this article as the state-of-the-art approach and an important reference for comparing the
new features of the exact MIBLP solver presented herein.
Finally, disjunctive cuts in connection to bilevel linear programming have been investigated in
Audet et al. (2007). However, there is no similarity between our intersection-cut based approach and
the disjunctive cuts given in Audet et al. (2007), where the cuts are used to enforce complementary
slackness conditions of the continuous follower subproblem, which is reformulated using KKT
conditions.
3. An Improved Branch-and-Cut Approach
It is well known that the HPR relaxation may provide arbitrarily weak lower bounds. Hence,
for enumerative methods relying on this relaxation, it is crucial to consider deep cuts that cut
off infeasible solutions early in the B&B tree, so as to improve the tightness of its lower and
upper bounds. This is in the spirit of other MIBLP approaches based on cutting planes, including
(DeNegre and Ralphs 2009, DeNegre 2011, Fischetti et al. 2016b).
Building on the approach proposed in (Fischetti et al. 2016b), we next introduce two new features
that have a significant impact on the solver performance: in Section 3.1 we describe locally valid
cuts, denoted as Follower Upper-Bound (FUB) cuts, that are based on an estimation of an upper
bound on the optimal solution value of the follower subproblem. In Section 3.2 we describe a new
preprocessing rule that allows fixing of some y values in HPR using information from the follower
MILP.
3.1. Follower Upper-Bound (FUB) Cuts
It is known that valid lower bounds for a bilevel problem in its value-function formulation (7)-(13),
can be obtained by restricting the follower subproblem and, consequently, overestimating the value
of Φ(x) for an arbitrary leader solution x; see, e.g., (Bhattacharjee et al. 2005a,b, Floudas and
Stein 2007, Mitsos et al. 2008, Kleniati and Adjiman 2015). In the following, we exploit this fact
inside of a B&C procedure, to derive valid cuts for the HPR relaxation.
Indeed, the value function reformulation (7)-(13) introduced in Section 1 is nonconvex due to the
presence of constraint (13). A valid lower bound on the optimal solution value at each B&B node can
be obtained by relaxing this constraint, and replacing Φ(x) with some constant overestimator for
the current node. This operation is just trivial for the B&B nodes where all the integer x variables
appearing in the follower MILP have been already fixed by branching. However, for the remaining
B&B nodes, one can exploit the local bounds on the x variables (x−, x+) at the current node, to
strengthen the HPR relaxation. We consider the following restriction of the follower subproblem:
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 9
in each follower constraint, x variables are replaced by the worst possible outcome for the follower,
thus resulting in an MILP on y variables only. The optimal solution of the latter MILP gives a
valid overestimation of Φ(x). We have the following result.
Theorem 1. Let (x−, x+) denote the bounds for the x variables at the current B&B node. Then
the following Follower Upper Bound (FUB) cut is locally valid for the current node:
dTy≤ FUB(x−, x+) (16)
where FUB(x−, x+) is the optimal solution value of the following restricted follower MILP
FUB(x−, x+) := miny
dTy (17)∑j∈Nx
max{Aijx−j ,Aijx
+j }+
∑j∈Ny
Bijyj ≤ bi, i= 1, . . . ,m (18)
l≤ y≤ u (19)
yj integer, ∀j ∈ Jy, (20)
and m denotes the number of rows of matrices A and B, and FUB(x−, x+) = +∞ in case the
problem is infeasible.
Proof It is enough to observe that, by construction, the above MILP is a restriction of the
follower MILP for any x with x− ≤ x≤ x+, which implies Φ(x)≤ FUB(x−, x+) for any such x. The
claim then follows as the FUB cut is just a relaxation of the value-function constraint (13) at the
current node. �
3.2. Follower Preprocessing
Preprocessing is a very important tool in modern MILP solvers, and for many problems has a
considerable impact on computing time. By design, our approach automatically exploits standard
MILP-based preprocessing whenever the follower MILPs are solved. There is however a bilevel-
specific preprocessing operation that is potentially very useful, in that it conveys relevant informa-
tion from the follower to the HPR. In particular, any y variables that can be fixed (for whatever
reason) in the follower MILP independently of x, can be fixed at the HPR level as well, thus poten-
tially improving the quality of the associated lower bound. We have the following result (recall
that the explicit constraints in the follower MILP (14) are in ≤ form, namely, Ax+By≤ b):
Theorem 2. For every follower variable yj (j ∈Ny), the following fixing is correct:
(a) if dj > 0 and Bj ≥ 0, fix yj to its lower bound lj by setting y+j := y−j := uj := lj;
(b) if dj < 0 and Bj ≤ 0, fix yj to its upper bound uj by setting y+j := y−j := lj := uj;
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs10 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Proof Given an x∗ ∈ Rn1 and a follower solution y that is feasible for (14), a follower feasible
solution of better cost can possibly be obtained by decreasing each variable yj with positive cost
and non-negative coefficients in all constraints, and/or by increasing each variable yj with dj < 0
and non-positive coefficients. Thus, any bilevel feasible solution will have yj = lj and yj = uj for
each variable j in cases (a) and (b), respectively. �
Note that in optimistic bilevel setting, the leader is free to choose among equivalent follower
solutions the one it prefers. Thus, we require the statement of Theorem 2 to be valid for any
optimal solution of the follower, yielding strict inequalities in cases (a) and (b). In case dj = 0 we
must preserve all equivalent optimal solutions, hence variable yj cannot be fixed.
As shown in the computational Section 7, the simple fixing of Theorem 2 can lead to a very
significant speedup when solving certain classes of instances.
4. New Families of Intersection Cuts
Intersection cuts were introduced by Balas (1971, 1972) and are widely used in the context of
MILPs; see (Andersen et al. 2005, 2007, Basu et al. 2011a,b, Conforti et al. 2010, Dey et al.
2014) among others. The reader is referred to Ch. 6 “Intersection Cuts and Corner Polyhedra”
in (Conforti et al. 2014) for a recent in-depth treatment of the subject. As customary in a B&C
context, given a bilevel-infeasible (possibly fractional) HPR point (x∗, y∗), one aims at deriving a
cutting plane that will cut off this point, while keeping the bilevel-feasible points intact. For an IC
to serve this purpose, one requires the definition of two sets:
(1) a cone pointed at (x∗, y∗) that contains all the bilevel feasible solutions, and
(2) a convex set S that contains (x∗, y∗) but no bilevel feasible solutions in its interior.
Typically, for a vertex (x∗, y∗) of HPR, a suitable cone is the corner polyhedron associated with
the corresponding optimal basis; see (Conforti et al. 2014) for details. In that case, the strength
of the derived IC only depends on the choice of the underlying convex set S, which is indeed the
topic of the present section.
Fischetti et al. (2016b) considered the bilevel-free set
S(y) = {(x, y)∈Rn : dTy > dT y, Ax+By≤ b} (21)
defined for an arbitrary point y ∈ Rn2 that satisfies (10) and (12). The fact that S(y) does not
contain bilevel-feasible solutions (x, y) derives easily from the observation that every such solution
has to satisfy the logical implications
Ax+By≤ b ⇒ Φ(x)≤ dT y ⇒ dTy≤ dT y.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 11
Implications of this type are typically translated into multi-term disjunctions of the form((Ax+By)1 > b1
) ∨. . .∨ (
(Ax+By)m > bm
) ∨ (dTy≤ dT y
),
(where m denotes the number of rows of matrices A and B) and used for branching within an
enumerative solution scheme; see, e.g., Xu and Wang (2014b). Alternatively, by exploiting the IC
theory they can also be used to derive valid inequalities to cut a given vertex (x∗, y∗) of HPR,
provided that (x∗, y∗) belongs to the interior of S(y)—a property that unfortunately cannot be
guaranteed in all cases as (x∗, y∗) may belong to its frontier. Under Assumption 3, however, set
S(y) can be extended by “moving apart” its facets by a non-negligible amount, resulting in the
following extended polyhedron
S+(y) = {(x, y)∈Rn : dTy≥ dT y, Ax+By≤ b+ 1}, (22)
(where 1 = (1, · · · ,1) denotes a vector of all ones) that can conveniently be used to derive violated
ICs; see (Fischetti et al. 2016b, Sect. 4.2) for details.
We next propose new ICs derived from alternative bilevel-free polyhedra. The ICs discussed in
Sections 4.1 and 4.2 require Assumption 3, while those in Section 4.3 do not need that assumption.
4.1. Alternative Bilevel-Free Polyhedra
As indicated above, by varying the definition of the bilevel-free convex set, different families of
valid ICs can be derived. Given the weak bounds of the HPR relaxation, the broader the family of
ICs the better the performance of the underlying B&C solver. This was the main motivation for
us to focus in this work on alternative ways for deriving and extending bilevel-free polyhedra. We
also show possible ways of enlarging these convex sets that may result in much stronger ICs.
With a little abuse of notation, in what follows we will call “facet” an inequality appearing in the
outer description of a polyhedron. The bilevel-free polyhedron in Theorem 3 below was introduced
by Xu (2012), where it has been used to determine branching rules in a B&B setting—while we
use it to derive hopefully deep ICs. As our theorem is stated in a slightly modified form, and for
the sake of completeness, we also provide a short proof.
Theorem 3. (Xu 2012) For any ∆y ∈Rn2 such that dT∆y < 0 and ∆yj integer for all j ∈ Jy, the
following polyhedron
X(∆y) = {(x, y)∈Rn :Ax+By+B∆y≤ b, l≤ y+ ∆y≤ u} (23)
does not contain any bilevel feasible point (not even on its frontier).
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs12 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Proof Let ∆y ∈ Rn2 be such that dT∆y < 0 and ∆yj integer for all j ∈ Jy, and consider any
(x, y) ∈X(∆y). If (x, y) is infeasible for the follower problem, then (x, y) is bilevel infeasible. If
(x, y) is feasible for the follower problem, then so is (x, y+ ∆y). Since dT (y+ ∆y)< dTy, y is not
an optimal solution of the follower problem for x, hence (x, y) is again not bilevel feasible.
�
Note that, contrarily to what happens with set S(y) defined in (21), some facets of X(∆y)
correspond to bound constraints on the y variables.
Also in case of this polyhedron, it may happen that a bilevel-infeasible HPR solution (x∗, y∗) to
be cut off does not belong to its interior. Therefore, we need to extend this set as follows:
Theorem 4. Under Assumption 3, for any ∆y ∈Rn2 such that dT∆y < 0 and ∆yj integer for all
j ∈ Jy, the following polyhedron does not contain any bilevel feasible point in its interior.
X+(∆y) = {(x, y)∈Rn : Ax+By+B∆y≤ b+ 1, l−1≤ y+ ∆y≤ u+ 1} (24)
Proof To be in the interior of X+(∆y), a bilevel feasible (x, y) should satisfy Ax+By+B∆y <
b+1 and l−1< y+ ∆y < u+1. Because of Assumption 3, the latter condition can be replaced by
Ax+By+B∆y≤ b and l≤ y+ ∆y≤ u, hence the claim follows from Theorem 3. �
Observe that the extended bilevel-free polyhedra X+(∆y) and S+(y) are not directly comparable,
i.e., typically it is not possible to find a y and a corresponding ∆y such that one of the two
polyhedra is a proper subset of the other—meaning that they are both of interest in our context;
see Figure 1 for an illustration. Indeed, the facets of X+(∆y) span the whole (x, y) space, while
those of S+(y) only span the y space (dTy ≥ dT y) or the x space (Ax+By ≤ b+ 1). In addition,
S+(y) contains the facet dTy ≥ dT y that directly involves the follower objective function, while
the role of the latter function in X+(∆y) is just implicit. As a matter of fact, the computational
experience reported in Section 7 shows that there is no dominance between the two polyhedra in
terms of IC quality.
4.2. Enlarged Bilevel-Free Polyhedra
The choice of the bilevel-free polyhedron is crucial for the computational effectiveness of the derived
IC: the larger the polyhedron the better. The following arguments can be applied to any bilevel-free
polyhedron to remove as many facets as possible from it, thus enlarging it and producing deeper
cuts.
Theorem 5. (Fischetti et al. 2016b) Let S = {(x, y) ∈ Rn : αTi x+ βT
i y ≤ γi, i = 1, . . . , k} be any
polyhedron not containing bilevel-feasible points in its interior. Then one can remove from S all
its facets i∈ {1, . . . , k} such that the half-space {(x, y)∈Rn : αTi x+βT
i y≥ γi} does not contain any
bilevel-feasible solution.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 13
Figure 1 Intersection cuts for a notorious example from Moore and Bard (1990): the LP vertex A is cut by an
IC (in red) obtained from the bilevel-free polyhedron S+(y) (left) or X+(∆y) (right), drawn in shaded
line. No dominance exists between the two cuts.
1 2 3 4 5 6 7 8 x
y
1
2
3
4A
y≤ 2
1 2 3 4 5 6 7 8 x
y
1
2
3
4A
37x+ 214y≤ 510
Concerning the set S+(y) defined by (22), the above property can possibly be used to remove
the facet dTy≥ dT y if a valid lower bound of the follower problem, say FLB, is known. Indeed, if
condition dT y < FLB holds, then the facet dTy≥ dT y can be removed from S+(y). This property is
particularly important and efficient for “zero-sum” bilevel instances where the leader and follower
objective functions satisfy cx = 0 and cy =−d in (1). In that case, at every B&B node, the incumbent
value z∗ (say) is an upper bound for the leader objective function, hence FLB =−z∗ is a lower
bound for the follower one.
Theorem 5 implies the following result:
Corollary 1. (Fischetti et al. 2016b) Let S = {(x, y) ∈Rn : αTi x+ βT
i y ≤ γi, i= 1, . . . , k} be any
polyhedron not containing bilevel-feasible points in its interior. Then one can remove from S all its
facets i∈ {1, . . . , k} such that
n1∑j=1
max{αijx+j , αijx
−j }+
n2∑j=1
max{βijy+j , βijy
−j }<γi. (25)
The above condition is exploited in Section 5.1 to derive large bilevel-free sets by solving an
auxiliary MILP that maximizes the number of facets satisfying it.
Concerning the extended bilevel-free polyhedron X+(∆y), Theorem 5 implies that, for a given
∆y, detection of redundant facets is immediate:
Corollary 2. Let X+(∆y) be the bilevel-free polyhedron of Theorem 4. Then, under Assump-
tion 3, one can remove from its definition all the facets (Ax + By + B∆y)i ≤ bi + 1 such that
(B∆y)i ≤ 0, along with all its facets (y + ∆y)i ≤ ui + 1 with ∆yi ≤ 0, and all its facets li − 1 ≤(y+ ∆y)i with ∆yi ≥ 0.
We observe that the above condition was also exploited in (Xu 2012) to reduce the number of
children of each B&B node.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs14 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
4.3. Hypercube Intersection Cuts
We finally present a very simple polyhedron (actually, a hypercube) that can be used to generate
ICs even when Assumption 3 does not hold.
Theorem 6. Assume JF ⊆ Jx. For any given HPR solution (x∗, y∗), let (x, y) be a min-cost bilevel-
feasible solution among those satisfying xj = x∗j for all j ∈ JF , computed as follows:
1. solve the follower MILP (14) for x= x∗ to compute Φ(x∗);
2. build a restricted HPR by adding the following constraints to HPR: xj = x∗j for all j ∈ JF , and
dTy≤Φ(x∗);
3. solve the restricted HPR, and let (x, y) be the optimal solution found (if any).
Then the following hypercube does not contain any bilevel-feasible solution strictly better than (x, y)
in its interior.
HC+(x∗) = {(x, y)∈Rn : x∗j − 1≤ xj ≤ x∗j + 1, ∀j ∈ JF} (26)
Proof Observe that the interior of HC+(x∗) only contains bilevel-feasible solutions (x, y) with
xj = x∗j = xj for all j ∈ JF . By construction, among these solutions, (x, y) is a best bilevel-feasible
one, hence the claim. �
Compared to the other two bilevel-free polyhedra, namely S+(y) and X+(∆y), this set spans
only the x space. Hypercube ICs play an important role for two classes of MIBLPs for which S+(y)
and X+(∆y) are not valid:
• if the follower subproblem is purely continuous (namely, for Jy = ∅), or
• if Assumption 3 does not hold.
In both cases, valid hypercube intersection cuts can still be derived from the polyhedron defined
by (26).
5. Separation Algorithms
We now address the question of how to cut a given (integer or fractional) vertex (x∗, y∗) of HPR
by using an IC. Given for granted that we use the cone associated with the current LP basis, as
explained in Section 4, what remains is the choice of the bilevel-free set to be used.
Note that our IC separation can fail in case (x∗, y∗) is not a feasible HPR solution, i.e., when
(x∗, y∗) does not satisfy the integrality requirements (11)–(12). This however does not affect the
correctness of our solution method, which is able to exclude fractional solutions by using standard
MILP cutting planes or branching—ICs being useful but not mandatory in this case.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 15
5.1. Separation of Intersection Cuts
For hypercube ICs, the choice of the bilevel-free set is uniquely defined by the coordinates of the
point (x∗, y∗). However, this is not the case for the sets S(y), S+(y), X(∆y), and X+(∆y) defined
above. Given that for deriving a violated IC the point (x∗, y∗) has to belong to the interior of the
bilevel-free set, we focus on the creation of the extended polyhedra S+(y) and X+(∆y). Recall that
these extended polyhedra are well-defined only under Assumption 3. Without loss of generality,
we also assume that (possibly after scaling) d is an integer vector so that the bilevel-infeasibility
conditions of the type dTy < dTy∗ can be replaced by dTy≤ dTy∗− 1.
Bilevel-Free Polyhedron S+(y). Given x∗, two options to define S+(y) have been proposed in
(Fischetti et al. 2016b), along with the MILP models for their detection. For the sake of complete-
ness, we briefly recall here the basic ideas behind these bilevel-free sets.
• SEP1: For the given HPR vertex (x∗, y∗), one solves the follower MILP to obtain its optimal
solution y, which eventually determines the set S+(y) according to (22). This approach aims
at maximizing the distance of (x∗, y∗) from the facet dTy≥ dT y of S(y). By construction, the
point (x∗, y∗) belongs to S(y), and hence to the interior of S+(y).
• SEP2: This is an alternative procedure that constructs y so as to have a large number of
“removable facets” according to Corollary 1, i.e., facets of the type (Ax+By)i ≤ bi + 1 with∑j∈Nx
max{Aijx−j ,Aijx
+j }+ (By)i ≤ bi. (27)
It consists of solving the following separation MILP:
y ∈ arg minm∑i=1
wi (28)
dTy≤ dTy∗− 1 (29)
By+ s= b (30)
si + (Lmaxi −L∗i )wi ≥Lmax
i , ∀i= 1, . . . ,m (31)
l≤ y≤ u (32)
yj integer, ∀j ∈ Jy (33)
s free (34)
w ∈ {0,1}m (35)
where, for each i= 1, . . . ,m,
L∗i :=∑j∈Nx
Aijx∗j ≤ Lmax
i :=∑j∈Nx
max{Aijx−j ,Aijx
+j }.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs16 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
In the model, the binary variable wi attains value 0 iff the facet (Ax + By)i ≤ bi + 1 can
be removed according to (27), hence the objective function (28) minimizes the number of
non-removable facets. Equations (30) define the slack variables si = (b−By)i, hence condition
s≥L∗ implied by (31) actually forces Ax∗+By≤ b. Together with (29), this guarantees that
(x∗, y∗) belongs to the interior of S+(y). Note that, in case wi = 0, constraint (31) becomes
si ≥Lmaxi (i.e.,
∑j∈Nx
max{Aijx−j ,Aijx
+j }+ (By)i ≤ bi), meaning the corresponding facet can
be removed according (27), as required.
Bilevel-Free Polyhedron X+(∆y). We now address the bilevel-free polyhedron X+(∆y) defined
in Theorem 4. Following the recipe of Xu (2012), for the given (x∗, y∗), ∆y is defined by solving
an additional MILP intended to produce a large number of removable facets in accordance with
Corollary 2. To simplify notation, let the system
Ax+ By≤ b
contain all the follower constraints (including the bounds on the y variables) except integrality,
and let m denote the number of rows of A. The separation MILP then reads:
∆y ∈ arg min∆y,t
m∑i=1
ti (36)
dT∆y≤−1 (37)
B∆y≤ b− Ax∗− By∗ (38)
∆yj integer, ∀j ∈ Jy (39)
B∆y≤ t and t≥ 0. (40)
In the model above, each continuous variable ti has value 0 in case (B∆y)i ≤ 0, meaning that
(Ax∗ + By∗ + B∆y)i ≤ bi + 1 is a removable facet according to Corollary 2. On the contrary, if
(B∆y)i > 0, variable ti measures the slack of solution (x∗, y∗) with respect to constraint i. So, the
objective function in (36) goes into the direction of maximizing the size of the bilevel-feasible set
associated with ∆y; see Xu (2012) for more details. Note that one is not allowed to increase by
1 the right-hand side of (38) as this would allow the point (x∗, y∗) to be on the frontier of the
extended polyhedron X+(∆y).
5.2. Numerically Safe Intersection Cuts
In this section we describe how ICs can be derived from the optimal LP basis in a numerically
reliable way. We follow the “disjunctive interpretation” of ICs (Glover 1974, Glover and Klingman
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 17
1976), which also reflects our actual implementation. This is a slightly more general—and numeri-
cally more stable—variant compared to those typically considered in the literature (Conforti et al.
2014).
To ease exposition, in the remaining part of this subsection we will denote by ξ = (x, y)∈Rn the
whole variable vector, while the HPR at the given B&B node will be formulated in its standard
form as
min{cT ξ : Aξ = b, ξ ≥ 0}.
Now let ξ∗ be an optimal vertex of the above LP, associated with a certain basis B (say) of A, and
let the bilevel-free polyhedron S of interest be defined as
S = {ξ : gTi ξ ≤ g0i, i= 1, . . . , k}.
Our order of business is to derive a valid inequality, violated by ξ∗, from the feasibility condition
“ξ cannot belong to the interior of S”. To this end, we observe that the latter condition can be
restated as the following k-term disjunction:
k∨i=1
(gTi ξ ≥ gi0) (41)
where we write ≥ instead of >, as a feasible ξ can in fact belong to the frontier of S.
Algorithm 1: Intersection cut separation
Input : An LP vertex ξ∗ along with its associated LP basis B;
the feasible-free polyhedron S = {ξ : gTi ξ ≤ g0i, i= 1, . . . , k} and the associated
valid disjunction∨k
i=1(gTi ξ ≥ gi0) whose members are violated by ξ∗;
Output: A valid intersection cut violated by ξ∗;
1 for i := 1 to k do
2 (gTi , gi0) := (gTi , gi0)−uTi (A, b), where uT
i = (gi)TBB−1
3 end
4 for j := 1 to n do γj := max{gij/gi0 : i∈ {1, . . . , k}} ;
5 if γ ≥ 0 then6 for j := 1 to n do7 if ξj is integer constrained then γj := min{γj,1} ;
8 end9 end
10 return the violated cut γT ξ ≥ 1
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs18 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
ICs are then obtained as in Algorithm 1. At Lines 1-3 each violated inequality gTi ξ ≥ gi0 is
restated in its equivalent reduced form gTi ξ ≥ gi0 where all basic variables ξj’s are projected away—
this is the standard operation that is applied to the objective function when computing LP reduced
costs. Observe that gi0 > 0 as the inequality is violated by ξ∗ whereas, by construction, gTi ξ∗ = 0.
Therefore, one can normalize it to 1gi0gTi ξ ≥ 1 to get a same right-hand side of 1 for all inequalities.
At Line 4, each inequality is relaxed so as to get a same left-hand-side coefficient for each variable
in all inequalities (through the max operation), meaning that the resulting relaxed cut γT ξ ≥ 1 is
valid for each term of the disjunction and hence for the overall problem. As the max operation does
not change the coefficient of each basic variable ξj (which is zero in all reduced-form inequalities),
the resulting cut is still violated (by 1) by ξ∗.
Finally, at Lines 5-9 a simple “coefficient clipping” operation is applied in case γ ≥ 0, that
consists of replacing γj by min{γj,1} whenever ξj is an integer-constrained variable. Validity of
the resulting inequality follows from the fact that either ξj = 0 (in which case its coefficient γj is
immaterial) or ξj ≥ 1 (hence validity follows from assumptions γ ≥ 0 and ξ ≥ 0).
It is important to observe that the validity of the final IC does not require the vectors uTi =
(gi)TBB−1 used at Line 2 to be computed with a very high numerical precision, as the cut coef-
ficients are computed by using the original data (A, b) and not the (possibly inaccurate) tableau
information. This property is very important for the correctness of the method—numerical issues
in computing uTi can reduce the cut violation as some basic variables can have a small nonzero
coefficient, but they do not have an impact on validity.
6. Implementation
In this section we describe some implementation details that play an important role in the design
of an effective code. Indeed, we strongly believe that these details are worth addressing for the sake
of result reproducibility. Our description is based on the actual MILP solver we used (IBM ILOG
Cplex 12.6.3), but it extends easily to other solvers.
The basic MILP model on which B&C is applied is HPR. Cplex’s preprocessing is disabled on this
model, as we need to retrieve LP bases at the various nodes (to derive ICs) and preprocessing would
change the variable space by aggregating/changing variables and constraints, requiring cumbersome
(if not impossible) bookkeeping mechanisms. Instead, we do apply our bilevel-specific preprocessing
variable fixing described in Theorem 2.
Internal numerical-precision thresholds for integrality/cut validity tests are set to a very small
value (10−9) so as to guarantee a very precise overall computation.
Multi-threading opportunistic parallel mode is selected when solving HPR, so as to fully exploit
the architecture in use. For thread safety, each thread works on its own copy of the follower MILP
(needed to check bilevel feasibility at B&B nodes).
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 19
Internal Cplex’s cuts are active in their default setting (level 0), as our approach does not require
to deactivate them—contrarily to, e.g., DeNegre (2011). Similarly, our approach could correctly
handle the solutions produced by Cplex’s internal heuristics (as shown below). Note however that
each solution found by internal Cplex’s heuristics requires a significant extra computation effort to
determine its bilevel feasibility. Thus, in our experiments, we deactivated all Cplex’s heuristics.
We implemented a bilevel-oriented branching strategy by using Cplex’s branching priorities.
To be specific, priority for integer-constrained variables is set to 2 (maximum) for all xj’s with
j ∈ Jx ∩ JF (i.e., appearing in the follower MILP), to 1 for xj’s with j ∈ Jx \ JF , and to 0 for all
other variables (i.e., for all yj’s with j ∈ Jy). Within the same priority level, Cplex is left free to
choose the branching variable according to its internal “strong branching” criterion.
Each time a new integer solution (x∗, y∗) is found and is going to update the incumbent, a specific
“lazyconstraint callback” function is automatically invoked by Cplex to let the user possibly discard
this solution for whatever reason, and possibly add a cut that makes this solution infeasible. In
this callback function, we first determine whether the solution is in fact bilevel-feasible by solving
the MILP follower for x = x∗, thus obtaining an alternative point (x∗, y) with dT y = Φ(x∗). If
dTy∗ >Φ(x∗), the solution (x∗, y∗) is not bilevel feasible and we cut it using a suitable IC. In case
heuristics were enabled and produced an infeasible candidate solution without an associated LP
basis, we could just discard it. In any case, point (x∗, y) is passed to an hoc-hoc feasibility-check
procedure that quickly verifies its HPR feasibility (with respect to (2)) and cost, and possibly
updates the incumbent. This approach is very useful as it typically produces very good heuristic
solutions at the very beginning of the computation.
Immediately before branching, at each node Cplex automatically invokes a “usercut callback”
function where the user can generate problem-specific (in our case, locally valid) cuts for fractional
HPR solutions. Within this function, we implemented separation procedures for both FUB cuts
and ICs, as described in Sections 3.1 and 5.1, respectively. Separation of FUB cuts is invoked
only at the first callback call at a given node, as it does not depend on (x∗, y∗) but only on the
variable bounds at the current node. Separation of ICs is instead active at each callback call,
with a maximum number (say, max node cuts) of consecutive calls at the same B&B node. This
limit was introduced for two reasons: first, separation procedures can be time-consuming, as they
require the solution of an auxiliary MILP; second, a known issue of ICs is that their effectiveness
quickly deteriorate when applied iteratively to the same LP. In any case, in our implementation, for
fractional HPR solutions we discard ICs with a too large dynamic (ratio between the largest and
smallest nonzero coefficient, both in absolute value, greater than 106) as they are not considered
numerically reliable. A cut is also discarded when its relative violation is very small, i.e., in case
its violation is smaller than 10−6 · (|cut rhs|+ 1).
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs20 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
7. Computational Results
To evaluate the performance of our improved B&C solution method, we implemented it (in C
language) and run it on a large set of instances both from the literature and randomly generated
ones. All computational experiments are conducted on an cluster consisting of Intel Xeon E5-2670v2
with 2.5GHz and 12GB of RAM. Computing times reported in what follows are in wall-clock
seconds and refer to 4-thread runs. The time limit for each run was set to 3 600 wall-clock seconds.
For research purposes, our solver is publicly available online at (Fischetti et al. 2017).
7.1. Testbed
Table 1 summarizes details about the data sets that have been considered in our computational
study. The considered instance sets can be divided into two groups: general bilevel, and interdiction.
While the former includes problems with no special structure, interdiction problems represent a
relevant case of bilevel programs where the follower typically is a clean combinatorial optimization
problem (e.g., a knapsack or an assignment problem). The leader can “interdict” a subset of
elements of the follower problem (e.g., knapsack items, or edges in the assignment problem), subject
to a given budget constraint. The objective of the leader is the opposite of that of the follower,
which results into min-max or max-min problems. Note that, by exploiting their special structure,
one can design sound methods for general interdiction problems (DeNegre 2011, Tang et al. 2016c).
In our computational study, instead, we treat interdiction problems as standard bilevel problems,
without taking advantage of their structure.
The total number of general bilevel instances considered is 307, and the total number of inter-
diction instances is 567. Thus, with experiments conducted on more than 850 instances of various
types and from different sources, our computational study is by far the most extensive ever reported
in the MIBLP literature. We note that, to the best of our knowledge, there are no instances in
literature considering continuous upper level variables and fulfilling Assumption 1. For this reason,
our testbed does not include instances with continuous variables in the leader.
General Bilevel Instances
• Instances of class DENEGRE have been proposed in DeNegre (2011). They involve n1 ∈ {5,10,15}
integer leader variables, while the number of integer follower variables n2 is such that n1 +n2 =
15 or 20. There are m = 20 follower constraints and no constraints at the leader level. All
coefficients are integers in the range [−50,50]. These instances, as well as all other instances
from (DeNegre 2011), namely INTER-KP, INTER-ASSIG, and INTER-RANDOM, are available at
(Ralphs and Adams 2016). Note that similar instances are also available in the open-source
repository (Ralphs 2015); according to the maintainer of the repository, however, some of them
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 21
have wrong coefficients that violate some assumptions required by DeNegre (2011), hence the
link (Ralphs and Adams 2016) should be used instead.
• Class MIPLIB has been introduced in Fischetti et al. (2016b). They are based on instances
of MILPLIB 3.0 (Bixby et al. 1998) containing only binary variables. These instances have
been transformed into bilevel problems by considering the first Y% (rounded up) variables
as follower variables, with Y ∈ {10,50,90} and the remaining ones as leader variables. The
objective function is used as the leader objective cTxx+ cTy y and the follower objective is set to
dTy =−cTy y. All constraints in the instances are defined to be follower constraints. The class
contains 57 instances with up to about 80 000 HPR variables and 5 000 follower constraints,
making them much larger (and often also much more difficult) than instances of the other
classes. These instances are available at (Fischetti et al. 2017).
• Class XUWANG has been proposed by Xu and Wang (2014b). In these instances, we have n1 =
n2 ∈ {10,60,110, . . . ,460}. The leader variables are constrained to be integer, while some of
the follower variables are continuous. The number of leader constraints, as well as follower
constraints, is 0.4n1. All input values are integers uniformly distributed from given ranges:
Gx,Gy,A,B are in [0,10], cx, cy, d are in [−50,50], q is in [30,130], and b is in [10,110]. The
leader variables have lower bound 0 and upper bound 10, while follower variables have lower
bound 0 and no upper bound; the latter ones are continuous with a probability of 50%. There
are ten instances for every value of n1. For n1 ∈ {110,160}, four additional sets of instances
were created: q is increased by 10 in the first two sets, while b in increased by 10 in the last two
sets. These instances are available at (Xu and Wang 2014a). Note that all these instances have
some continuous follower variables, hence Assumption 3 does not hold and only the hypercube
ICs of Section 4.3 can be used by our B&C solver.
• To better analyze the cases where Assumption 3 does not hold (and thus only hypercube
ICs can be used), we created a new class XUWANG-LARGE of larger random instances by fol-
lowing the same procedure used for class XUWANG. For this new class we have n1 = n2 ∈
{500,600, . . . ,1000}, and we generated 10 instances for each value of n1. All instances are
available at (Fischetti et al. 2017).
Interdiction Instances
• Class INTER-KP has been introduced in DeNegre (2011). The follower problem is a knapsack
problem. The instances are based on bicriteria knapsack instances from the multiple criteria
decision making library : the first objective of the bicriteria problem is used to the define
the follower objective function, while the second objective defines the interdiction budget
constraint of the leader. The instances have n1 = n2 ∈ {10,20, . . .50}, with two additional sets
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs22 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
with 11 and 12 items. The interdiction budget of an instance is d∑n1
i=1 ai/2e, where ai is the
cost of interdicting item i. For every number of items there are 20 instances, except for 10
items where there are 40 instances.
• Class INTER-KP2 has been proposed by Tang et al. (2016c) and also consists of knapsack
interdiction instances. Instances with number of items n1 = n2 ∈ {20,22,25,28,30} have been
constructed and the interdiction budget is a cardinality constraint allowing k (say) items to
be interdicted. For each value of n1, three different values of k have been considered and,
for each (n1, k) pair, ten instances have been defined generating item weights and profits as
random integers in [1,100]. These instances are available at (Tang et al. 2016b).
• Instances of class INTER-ASSIG have also been introduced in DeNegre (2011). The follower
problem is an assignment problem. The instances are derived from bicriteria assignment
instances from the multiple criteria decision making library in a similar way as in class
INTER-KP. Each instance has 25 edges (i.e., n1 = n2 = 25) and 20 follower constraints—plus
the interdiction constraints stipulating that interdicted edges cannot be used by the follower.
The interdiction budget was chosen as a percentage of the sum of interdiction costs.
• Class INTER-RANDOM are random interdiction problems proposed by DeNegre (2011). They
are based on random ILPs with integer coefficients in [−50,50] of size (rows × columns)
10× 10, 15× 10, 20× 20, and 25× 20. These ILPs are transformed to interdiction instances
by introducing interdiction costs for each variable. Two strategies are considered: in the first
strategy, a unit cost is given, together with an interdiction budget of 3. In the second one,
interdiction costs and budget are taken randomly. Instances obtained by applying the first and
second strategy are denoted as symmetric and asymmetric, respectively. For each strategy, 10
instances are generated for each size.
• Class INTER-CLIQUE are clique interdiction problems introduced in Tang et al. (2016c). The
follower problem is a maximum cardinality clique problem, and the leader can interdict edges.
Graphs with ν = {8,10,12,15} nodes and edge densities d∈ {0.7,0.9} have been used to define
the instances. The interdiction budget is a cardinality constraint, and the leader can interdict
at most dm/4e edges, where m is the number of edges in the graph. For each combination of
ν and d, ten instances have been constructed, resulting in 80 instances of this class. These
instances are available at (Tang et al. 2016a).
• Instances of class INTER-FIRE have been recently introduced in Baggio et al. (2016). These
are randomly generated problems arising from a trilevel context in which one has to defend
a given network against possible cascade failures or malicious viral attacks. This benchmark
includes instances in which the network is a tree or a general graph. In both cases, the number
of nodes is in {25, 50, 80}. These instances were available from the authors of (Baggio et al.
2016), and can also be downloaded from (Fischetti et al. 2017).
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 23
Table 1 Our testbed. The first four classes are of general bilevel type, and the latter six of interdiction type.
Column Type indicates whether the instances are binary (B), integer (I) or continuous (C), column #Inst reports
the total number of instances in each class, column #OptB gives the number of instances solved to optimality by
previous approaches from literature, and #Opt gives the number of instances solved to optimality by the solver
presented in this paper. The symbols in the column #OptB give the source of the previous best approach: † is
(Fischetti et al. 2016b); + is (Xu and Wang 2014b); ∗ is (Tang et al. 2016c). Note that classes XUWANG-LARGE and
INTER-FIRE have not been tested computationally before. For class INTER-RANDOM some results are reported in
(DeNegre 2011), but for different instances.
Class Source Type #Inst #OptB #Opt
DENEGRE (DeNegre 2011),(Ralphs and Adams 2016) I 50 45† 50MIPLIB (Fischetti et al. 2016b) B 57 20† 27XUWANG (Xu and Wang 2014b) I,C 140 140+ 140XUWANG-LARGE this paper I,C 60 - 60
INTER-KP (DeNegre 2011),(Ralphs and Adams 2016) B 160 79† 138INTER-KP2 (Tang et al. 2016c) B 150 53? 150INTER-ASSIG (DeNegre 2011),(Ralphs and Adams 2016) B 25 25† 25INTER-RANDOM (DeNegre 2011),(Ralphs and Adams 2016) B 80 - 80INTER-CLIQUE (Tang et al. 2016c) B 80 10? 80INTER-FIRE (Baggio et al. 2016) B 72 - 72
total 874 372 822
7.2. Computational Analysis of the Proposed Improvements
In this subsection we computationally analyze the effect of the newly presented ingredients on
the performance of our bilevel B&C solver. We first consider FUB cuts, as described in Section
3.1, and then follower preprocessing (cf. Section 3.2). Afterwards, we investigate the influence of
new bilevel-free sets introduced in Section 4. In this experiment, the following solver settings are
considered:
– SEP1: our B&C solver using SEP1 formulation for separating ICs (see Section 5.1);
– SEP2: our B&C solver using SEP2 formulation for separating ICs (see Section 5.1);
– XU: our B&C solver with the extended bilevel-free set of Xu (2012) as described in Section
4.1;
– MIX: combination of settings SEP2 and XU (both ICs being separated at each separation call).
Observe that settings SEP1 and SEP2 have been proposed and analyzed by Fischetti et al. (2016b),
where it has been shown that SEP2 outperforms previous MIBLP approaches from the literature
by a large margin. In the present article, these two settings serve therefore as reference points for
measuring the efficacy of the newly proposed features (notably: FUB cuts, preprocessing, and new
ICs) exploited in our new proposals XU and MIX. For all settings, at most max node cuts=20 ICs
are separated at each B&B node (including root). When one of the four settings is enhanced by
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs24 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
FUB cuts or by preprocessing, this is denoted by a “+F” or by “+P” next to its name, respectively.
If both FUB cuts and preprocessing are active, this is denoted by “++”.
In the following, we first analyze the effects of FUB cuts and the preprocessing, before turning
these two features on for the remainder of the study.
Effect of FUB Cuts. We illustrate the importance of the FUB cuts introduced in Section 3.1
through the cumulative speed-up chart of Figure 2a, addressing the 50 instances of set DENEGRE.
The chart shows the speed-up values for the two state-of-the-art approaches from Fischetti et al.
(2016b), namely, settings SEP1 and SEP2. To see the effect of FUB cuts, the follower preprocessing is
turned off. The reported speed-up ratio is calculated as t(SEPx)+tst(SEPx+F)+ts
, where t(SEPx+ F) and t(SEPx)
denote the computing time (in seconds) of a setting SEPx with and without FUB cuts, respectively.
The time shift ts is set to 1 second to reduce the importance of instances that are too easy in the
comparison. For a given setting, each point (x, y) in this chart indicates that y% of all instances
have a speed-up ratio of at least x. Notice that the values on x axis are given in log-scale. We
observe that for both SEP1 and SEP2 a significant speed-up is achieved in the considered dataset. In
some cases, a speed-up of 2-3 orders of magnitude could be reported, thanks to the usage of FUB
cuts. In very few cases, a small slow-down is observed—this usually happens for instances that
could be solved within a few seconds, in which case turning FUB cuts on causes an unnecessary
overhead.
Effect of Follower Preprocessing. We now demonstrate the effect of follower preprocessing
using the same set of DENEGRE instances. The speed-up ratio is now calculated as t(SEPx)+tst(SEPx+P)+ts
, where
t(SEPx+ P) and t(SEPx) denote the computing time (in seconds) of a setting SEPx with and without
the follower preprocessing, respectively.
The cumulative chart reporting this speed-up ratio is given in Figure 2b. For about 40% (SEP1+P),
resp., almost 50% (SEP2+P) of the instances, a speed-up of at least one order of magnitude is
achieved—for about 25% of the instances, the actual speed-up is of two orders of magnitude or
even higher.
Effect of Using Both FUB Cuts and Follower Preprocessing. Figure 2c shows the effect
of turning on both FUB cuts and follower preprocessing, for the set of DENEGRE instances. The
speed-up ratio is calculated as t(SEPx)+tst(SEPx++)+ts
, where t(SEPx+ +) and t(SEPx) denote the computing
time (in seconds) of a setting SEPx with and without both FUB cuts and the follower preprocessing,
respectively. The results are very similar to those in Figure 2b, which suggests that, for this instance
class, the improved performance of both SEP1 and SEP2 is mainly due to follower preprocessing.
However, for more difficult instances the use of FUB cuts together with preprocessing does yield
an additional performance improvement, as shown in the MIPLIB tests reported below.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 25
Figure 2 Speed-ups achieved by FUB cuts and follower preprocessing for the instance set DENEGRE.
●●
●●●
●●
●●
●●
●●●
●●●
●●●●●
●●●●●●●●●●●●●●●●●●●●●●●●●●●●
0
25
50
75
100
100 101 102 103
At least x times faster when using FUB cuts
#in
stan
ces
[%]
Setting● SEP1/SEP1+F
SEP2/SEP2+F
(a) Using FUB cuts.
●●●●
●●
●●
●●●
●●
●●
●●
●●
●●
●●
●●●
●●●
●●●●
●●●
●●●●●●●●●●●●●●
0
25
50
75
100
100 101 102 103
At least x times faster when using preprocessing
#in
stan
ces
[%]
Setting● SEP1/SEP1+P
SEP2/SEP2+P
(b) Using follower preprocessing.
●●●●
●●
●●
●●
●●
●●
●●
●●
●●
●●
●●
●●
●●●●
●●●
●●●●●●●●●●●●●
●●
●●
0
25
50
75
100
100 101 102 103
At least x times faster when using both preprocessing and FUB cuts
#in
stan
ces
[%]
Setting● SEP1/SEP1++
SEP2/SEP2++
(c) Using both follower preprocessing and FUB cuts.
To further analyze the effects of FUB cuts and follower preprocessing, we next illustrate the
improvement in performance of setting SEP2 when combined with FUB cuts and follower pre-
processing (and both) on the most challenging set of benchmark instances in our study, namely
MIPLIB. Figure 3 shows the cumulative chart for final gaps obtained after the time limit of one
hour for SEP2, SEP2+F, SEP2+P, and SEP2++. Percentage gaps are calculated as 100·(BestSol −
LB)/(|BestSol|+ 10−10), where BestSol and LB are the best upper and lower bounds found by a
given setting, respectively. For visualization, gaps larger than 100% are set to 100%; similarly, if a
setting did not find a feasible solution within the time limit, we also set the gap to 100%.
For each setting, each point (x, y) in this chart indicates that y% of all instances have a resid-
ual percentage gap not larger than x. In particular, the left-most point indicates the percentage
of instances solved to optimality for each of the settings. These results show that a significant
performance improvement can be achieved: SEP2 manages to solve about 34% of the instances to
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs26 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Figure 3 Final gaps for settings SEP2, SEP2+F, SEP2+P, and SEP2++ for instance set MIPLIB, obtained when the
time limit of one hour is reached.
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
40
60
80
100
0 25 50 75 100%gap
#in
stan
ces
[%]
Setting● SEP2
SEP2+PSEP2+FSEP2++
optimality, and this figure increases to 39% for SEP2+F and to 42% for SEP2+P and SEP2++. As
to the residual gaps for the unsolved instances, we observe that both SEP2+F and SEP2+P clearly
improve on SEP2, with SEP2+P having a larger effect. Combining both (code SEP2++) improves the
performance even further. For example, the final gap is at most 50% for about 74% of instances
if SEP2 is used, while this latter figure grows to about 77% when using SEP2+F, to slightly above
80% when using SEP2+P, and to about 83% when using SEP2++.
Effect of Different Intersection Cuts. We next compare our new approach for separating
ICs based on the definition of the bilevel-free set given in (24) (the resulting code being denoted by
XU) against the recently-proposed ICs based on bilevel-free sets defined by (22) (denoted by SEP2).
In addition, we consider a mixed strategy (denoted by MIX), in which both ICs are generated for
each separation call. To also analyze the effect of FUB cuts and preprocessing in combination with
these different approaches for generating intersection cuts, we also consider settings where these
two features are both turned on—this is indicated with ++ beside the setting names (i.e., setting
XU++, SEP2++, MIX++).
Computational performance is compared using performance profiles (PPs), which are constructed
following the procedure of Dolan and More (2002). For each setting s ∈ S and instance p ∈ P , a
performance ratio rp,s =tp,s
mins′∈S{tp,s′}is calculated, where tp,s is the time setting s needs to solve
instance p. In the profiles, the cumulative distribution function of the performance ratio ρs(τ) =
100|P |
∣∣{p ∈ P : rps ≤ τ}∣∣ is displayed for each setting s ∈ S. The leftmost point of the graph for a
setting s shows the percentage of instances for which s is the fastest setting.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 27
In both Figures 4 and 5 we report two PPs: one for the class of general bilevel instances (Figures
4a and 5a), and one for the class of interdiction instances (Figures 4b and Figures 5b). In Figure
4, we only consider settings without FUB cuts and preprocessing, while in Figure 5 all settings
are considered. All PPs refer to the subsets of instances that could be solved to optimality by all
three (respectively, six) settings within the given time limit of one hour. These are 55 out of the
107 general bilevel instances of classes DENEGRE and MIPLIB, and 353 out of the 567 interdiction
instances; most of these instances are solved to optimality within a few seconds by every setting.
Recall that, for sets XUWANG and XUWANG-LARGE, none of the six settings is applicable as only
hypercube ICs can be used.
Figure 4a shows that, for general bilevel instances, both XU and MIX perform very similarly,
and they considerably outperform SEP2. For interdiction instances (Figure 4b) the situation is
different, as MIX and SEP2 perform similarly (with SEP2 performing slightly better) and both
settings considerably outperform XU. Thus we conclude that setting MIX, which combines both
types of intersection cuts, qualifies as a robust choice for all considered sets of instances. Of course,
this choice implies a small overhead in runtime caused by the separation and use, at each iteration,
of two ICs instead of one.
Next, we turn our attention to the effect of adding FUB cuts and preprocessing to the intersection
cuts. For general bilevel instances, we see in Figure 5a that for SEP2, a drastic improvement is
achieved by adding FUB and preprocessing; for XU and MIX, there is also an improvement, but it
is not that pronounced. All “++” settings give good performance for these instances.
For the interdiction instances, the results in Figure 5b show that both SEP2++ and MIX++ (and
the basic variants of these two settings) vastly outperform XU++, and that XU++ in turn outper-
forms XU by a large margin. We observe that, due to the definition of the considered interdiction
problems, the conditions of Theorem 2 are never fulfilled, thus the preprocessing has no effect on
these types of instances. The slight improvement of SEP2++ over MIX++ can again be attributed
to the overhead of separating and using two ICs instead of one.
Figures 6a and 6b report cumulative-gap charts (similar to those in Figure 3) for the complete
set of general bilevel and interdiction instances, respectively. Figure 6a shows that MIX++ manages
to solve most instances of general bilevel to optimality, namely about 73% The next best settings
are XU++ (solving about 70%) and SEP2++ (solving about 67%). For the general bilevel instances,
a clear performance improvement can be seen when using FUB cuts and preprocessing, the effect
being especially pronounced for code SEP2. Figure 6a shows that about 10% more instances could
be solved to optimality using SEP2++ compared to SEP2, while for XU++ (vs XU) and MIX++ (vs
MIX) this number is about 7%.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs28 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Figure 4 Effect of different ICs without FUB cuts or preprocessing on the B&C performance. Performance profiles
contain instances that could be solved to optimality by all three settings.
●●●●●●●●●●●●●
●●
●●
●●
●●●
●●
●●
●●
●●
0
25
50
75
100
1 5 10No more than x times worse than best configuration
#in
stan
ces
[%]
Setting● SEP2
XUMIX
(a) Instances of type general bilevel.
●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
●●●●●●●●●●
0
25
50
75
100
1 5 10No more than x times worse than best configuration
#in
stan
ces
[%]
Setting● SEP2
XUMIX
(b) Instances of type interdiction.
These results show that, for general bilevel instances, the presence of FUB cuts and preprocessing
provides a considerable speedup, thus confirming the outcomes of the experiments depicted in
Figure 2. On the contrary, results of Figure 6b on interdiction instances are mixed: on the one
hand there is no significant difference between SEP2++ and SEP2 (and also between MIX++ and
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 29
Figure 5 Effect of different ICs on the B&C performance. Performance profiles contain instances that could be
solved to optimality by all six settings.
●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
●●
●●●
●●●
●●
0
25
50
75
100
1 5 10No more than x times worse than best configuration
#in
stan
ces
[%]
Setting● SEP2++
XU++MIX++SEP2XUMIX
(a) Instances of type general bilevel.
●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
●●●●●● ●
0
25
50
75
100
1 5 10No more than x times worse than best configuration
#in
stan
ces
[%]
Setting● SEP2++
XU++MIX++SEP2XUMIX
(b) Instances of type interdiction.
MIX), with all of them solving about 95% of the instances to optimality; on the other hand, XU++
turns out to vastly outperform XU (solving about 83% vs solving about 63%).
Overall, these experiments show that MIX++, which combines SEP2++ and XU++, has some
unavoidable overhead but solves more instances to optimality—and produces smaller final gaps for
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs30 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
many of the unsolved cases. Thus, we conclude that setting MIX++ qualifies as a robust configu-
ration for our B&C algorithm, to be used as default setting.
Figure 6 Cumulative chart for final gaps demonstrating the effect of different ICs on the B&C performance.
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
●
60
70
80
90
100
0 25 50 75 100Number of instances with optimality gap at most x %
#in
stan
ces
[%]
Setting● SEP2++
XU++MIX++SEP2XUMIX
(a) Instances of type general bilevel.
● ● ●●●●●● ● ●● ●●●
●● ●●●●● ● ● ●● ●●●
●
60
70
80
90
100
0 25 50 75 100Number of instances with optimality gap at most x %
#in
stan
ces
[%]
Setting● SEP2++
XU++MIX++SEP2XUMIX
(b) Instances of type interdiction.
Performance of Hypercube Intersection Cuts. In Table 2 we give results for set
XUWANG-LARGE where, similarly to the set XUWANG to be addressed in the next section, only the
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 31
hypercube ICs can be applied. In this table, we compare the setting with FUB cuts and prepro-
cessing turned on (code HC++), against both turned off (code HC). It can be seen that, even for this
class of instances, our methods manage to solve all instances to optimality. Using FUB cuts and
preprocessing brings a speed-up of about 2-3 times.
Table 2 Results for instance set XUWANG-LARGE. Entries in the table give runtime to optimality, in seconds.
n1 setting i= 1 i= 2 i= 3 i= 4 i= 5 i= 6 i= 7 i= 8 i= 9 i= 10 avg
500 HC 763 1370 293 461 1161 203 1210 858 299 1302 792.1500 HC++ 245 697 84 183 1076 174 737 352 237 287 407.3600 HC 1082 1480 598 993 149 764 358 302 309 1409 744.6600 HC++ 452 475 375 643 176 666 173 210 189 928 428.6700 HC 2645 579 1885 1511 618 943 1514 1601 1080 486 1286.2700 HC++ 622 311 1064 862 377 711 591 923 598 298 635.8800 HC 2026 1589 1428 1616 1069 1537 849 1082 1295 1133 1362.4800 HC++ 958 855 934 646 667 759 405 634 471 457 678.7900 HC 2104 2314 1533 2397 1518 1951 2172 2263 1810 2217 2027.9900 HC++ 816 750 592 739 679 580 770 409 460 631 642.61000 HC 1407 2679 2227 3069 3211 3306 2400 2334 2099 2498 2523.11000 HC++ 746 1442 941 1999 1994 2110 993 1507 787 903 1342.2
7.3. Comparison with Approaches from Literature
In this subsection we compare our default B&C code MIX++ with other approaches from the lit-
erature, using the same instance classes on which the latter have been originally tested. When
performing this experiment, we refrained from tuning our solver for the specific instance subclasses,
even though this could produce significantly better results in many cases.
Not all instances listed in Table 1 are considered in this subsection, namely, instances from
INTER-ASSIG, INTER-FIRE and INTER-RANDOM are left out. Instances of class INTER-ASSIG are
omitted for the sake of space, as they turn out to be very easy for both MIX++ and the state-of-the-art
solver for these problems—namely, SEP2 from (Fischetti et al. 2016b). As to INTER-FIRE problems,
no computational analysis has been carried out so far in the literature, while for INTER-RANDOM
the only available results are from (DeNegre 2011), but for different instances (see the discussion
in Section 7.1). In our computational analysis, we did not consider solution approaches that were
designed for bilevel mixed-integer nonlinear programs (see Section 2), as the comparison could be
biased in favour of our MIBLP-specific code—and also because no implementation of the nonlinear
approaches is publicly available online.
Instance Set DENEGRE. For this class of 50 general bilevel instances introduced by DeNegre
(2011), Table 3 compares the performance of two solvers: SEP1 (in a variant with max node cuts
= 0 that produces the best-known results for this class, as reported by Fischetti et al. (2016b))
and MIX++ (our default B&C solver). For the former we report, for each instance, the value of
the best lower and upper bounds (LB and BestSol, respectively), the associated percentage gap
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs32 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
(%gap), the computing time (in seconds), as well as the total number of branch-and-bound nodes.
As MIX++ is able to solve to proven optimality all the instances, for this solver we only report the
required computing time and number of nodes. The optimal solution value of each instance is given
in column OPT . Prior to the present work, optimal solutions for five instances of this class were
unknown.
We point out that with our new B&C solver, optimal solutions for all the 50 instances of this
class are reported (five instances for the first time), and that the optimal solution for all but two
instances is obtained within only a few seconds of computing time. Moreover, MIX++ needs much
fewer branch-and-bound nodes than SEP1.
Instance Set XUWANG. In Xu and Wang (2014b), a generic solver for MIBLPs has been intro-
duced, along with a set of 140 instances, comprising integer leader variables, and continuous follower
variables. In the following, we perform a comparison of our B&C solver with the solver of Xu and
Wang (2014b). As Assumption (3) does not hold for the follower subproblem, our solver relies on
the separation of the hypercube ICs of Subsection 4.3 only. FUB cuts and preprocessing remain
valid in this case, and are turned on in our experiment.
Both approaches solve all 140 instances from this class to optimality. Table 4 reports the required
computing times. Each table row corresponds to a set of ten instances and computing times of
our solver are given per instance (for i= 1, . . . ,10) and on average (column avg). The rightmost
column (avg-XU ) gives instead the average computing time of the solver introduced in Xu and
Wang (2014b), and refers to a “desktop computer with 2.4 GHz”, which is therefore 2 to 5 time
slower than our hardware. The table shows that, after taking the hardware differences into account,
our approach remains orders of magnitude faster than the one presented in Xu and Wang (2014b),
in particular for the largest instances. Indeed, for the instances with n1 = 460 our solver has an
average computing time of 23.1 seconds, against 6 581.4 seconds reported in Xu and Wang (2014b).
Moreover, for instances of class B2-160, which seem the hardest in this testbed, the speed-up is
even more pronounced with average computing times of 37.4 versus 22 999.7 seconds.
Instance Sets INTER-KP2 and INTER-CLIQUE. Another generic solver for zero-sum MIBLPs
has been recently proposed in Tang et al. (2016c), along with two families of benchmark instances
of interdiction type on which the solver is tested: knapsack-interdiction and clique-interdiction,
denoted by INTER-KP2 and INTER-CLIQUE in the following. We compare our default setting for
the B&C solver, namely MIX++, with the best results reported in Tang et al. (2016c), which have
been obtained “on a PC with 3.30 GHz using CPLEX 12.5”. The results of this comparison are
summarized in Table 5. Each row reports average results over a subset of ten instances that share
the same (n1, k) pair (left part of the table, INTER-KP2 instances) or the same graph-parameters
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 33
Table 3 Results for instance set DENEGRE.
SEP1 MIX++
instance OPT BestSol LB %gap time [s] nodes time [s] nodes
miblp-20-15-50-0110-10-10 -206 -206 -206.0 0.0 0 628 0 10miblp-20-15-50-0110-10-1 -388 -388 -388.0 0.0 0 50 1 21miblp-20-15-50-0110-10-2 -398 -398 -398.0 0.0 17 77323 8 279miblp-20-15-50-0110-10-3 -42 -42 -42.0 0.0 0 2201 2 54miblp-20-15-50-0110-10-4 -729 -729 -729.0 0.0 0 185 1 56miblp-20-15-50-0110-10-5 -281 -281 -281.0 0.0 0 83 0 20miblp-20-15-50-0110-10-6 -246 -246 -246.0 0.0 0 233 16 205miblp-20-15-50-0110-10-7 -260 -260 -260.0 0.0 0 108 0 0miblp-20-15-50-0110-10-8 -293 -293 -293.0 0.0 0 114 0 22miblp-20-15-50-0110-10-9 -635 -635 -635.0 0.0 0 1061 1 16miblp-20-20-50-0110-10-10 -441 -441 -441.0 0.0 73 256927 2927 8068miblp-20-20-50-0110-10-1 -359 -359 -359.0 0.0 494 1805080 2 81miblp-20-20-50-0110-10-2 -659 -659 -659.0 0.0 0 939 1 17miblp-20-20-50-0110-10-3 -618 -618 -618.0 0.0 1 9456 0 52miblp-20-20-50-0110-10-4 -604 -604 -695.0 15.1 3600 7479668 1 51miblp-20-20-50-0110-10-5 -1003 -1003 -1003.0 0.0 0 20 0 13miblp-20-20-50-0110-10-6 -731 -707 -858.4 21.4 3600 6244669 10 511miblp-20-20-50-0110-10-7 -683 -683 -683.0 0.0 2788 7420465 0 54miblp-20-20-50-0110-10-8 -667 -667 -667.0 0.0 3 8116 15 232miblp-20-20-50-0110-10-9 -256 -256 -256.0 0.0 4 42945 0 71miblp-20-20-50-0110-15-10 -251 -251 -251.0 0.0 0 400 0 14miblp-20-20-50-0110-15-1 -450 -420 -511.7 21.8 3600 4313453 0 16miblp-20-20-50-0110-15-2 -645 -645 -744.0 15.3 3600 14175981 0 6miblp-20-20-50-0110-15-3 -593 -593 -593.0 0.0 838 1420792 3 43miblp-20-20-50-0110-15-4 -441 -441 -487.7 10.6 3600 5448638 5 131miblp-20-20-50-0110-15-5 -379 -334 -518.0 55.1 3600 6169959 1392 5466miblp-20-20-50-0110-15-6 -596 -596 -596.0 0.0 3260 5955753 50 483miblp-20-20-50-0110-15-7 -471 -471 -471.0 0.0 246 787848 0 23miblp-20-20-50-0110-15-8 -370 -370 -838.4 126.6 3600 11797237 0 3miblp-20-20-50-0110-15-9 -584 -584 -584.0 0.0 1 2027 0 8miblp-20-20-50-0110-5-10 -340 -340 -340.0 0.0 0 45 0 38miblp-20-20-50-0110-5-11 -426 -426 -426.0 0.0 0 9 0 11miblp-20-20-50-0110-5-12 -854 -854 -854.0 0.0 0 43 0 21miblp-20-20-50-0110-5-13 -519 -519 -519.0 0.0 116 947138 0 11miblp-20-20-50-0110-5-14 -923 -923 -923.0 0.0 0 109 0 58miblp-20-20-50-0110-5-15 -617 -617 -617.0 0.0 157 1031098 1 197miblp-20-20-50-0110-5-16 -833 -833 -833.0 0.0 0 2535 0 44miblp-20-20-50-0110-5-17 -944 -944 -944.0 0.0 0 3580 0 19miblp-20-20-50-0110-5-18 -386 -386 -386.0 0.0 0 2 0 0miblp-20-20-50-0110-5-19 -431 -431 -431.0 0.0 3 25762 0 95miblp-20-20-50-0110-5-1 -548 -548 -548.0 0.0 1 6981 0 21miblp-20-20-50-0110-5-20 -438 -438 -438.0 0.0 0 3918 0 32miblp-20-20-50-0110-5-2 -591 -591 -591.0 0.0 1558 6053523 0 49miblp-20-20-50-0110-5-3 -477 -477 -477.0 0.0 0 53 0 50miblp-20-20-50-0110-5-4 -753 -753 -753.0 0.0 0 142 0 71miblp-20-20-50-0110-5-5 -392 -392 -392.0 0.0 0 51 0 31miblp-20-20-50-0110-5-6 -1061 -1061 -1061.0 0.0 5 79502 0 92miblp-20-20-50-0110-5-7 -547 -547 -547.0 0.0 0 80 0 16miblp-20-20-50-0110-5-8 -936 -936 -936.0 0.0 0 69 0 91miblp-20-20-50-0110-5-9 -877 -877 -877.0 0.0 0 112 0 62
(right part, associated with INTER-CLIQUE instances). For the solver of Tang et al. (2016c), we
report the average computing time (in seconds), the average value of the best known upper bound
(BestSol), the average final lower bound (obtained after one hour of computing) and the total
number of unsolved instances out of ten (denoted by #unsol). For MIX++ we only report the average
computing time in seconds, as it turns out that our solver manages to solve all 150 + 80 instances
to optimality (compared to 53 + 10 for the best solver from Tang et al. (2016c)). For INTER-KP2
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs34 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Table 4 Results for the instance set XUWANG. Computing times (in seconds) given for ten instances (i = 1, . . . ,10)
for fixed n1. Column avg-XU gives the average computing times as reported in Xu and Wang (2014b).
n1 i= 1 i= 2 i= 3 i= 4 i= 5 i= 6 i= 7 i= 8 i= 9 i= 10 avg avg-XU
10 3 3 3 3 2 3 2 3 2 3 2.6 1.460 2 0 0 1 1 1 1 1 2 2 0.9 45.6110 2 1 2 2 1 2 1 2 2 12 2.8 111.9160 2 2 3 2 3 1 4 1 1 3 2.1 177.9210 2 3 1 1 3 3 3 2 5 3 2.6 1224.5260 3 4 3 6 3 5 6 2 7 11 5.0 1006.7310 5 10 11 14 7 16 15 8 5 3 9.4 4379.3360 17 28 11 13 11 15 7 19 9 14 14.4 2972.4410 19 10 29 8 21 10 9 15 23 42 18.7 4314.2460 22 10 22 35 21 21 32 22 23 23 23.1 6581.4B1-110 0 0 0 0 0 1 0 1 0 9 1.3 132.3B1-160 1 1 3 1 2 1 3 0 0 2 1.3 184.4B2-110 16 2 2 8 1 25 15 5 1 122 19.7 4379.8B2-160 8 38 21 91 34 4 40 3 12 123 37.4 22999.7
the average computing times of MIX++ vary between a fraction of a second to five minutes. The set
INTER-CLIQUE turns out to be much easier, as in most of the cases, optimal solutions are found
within a fraction of a second. Only for the largest instances with 15 nodes and graph density of 0.9,
our solver requires about 12 seconds on average. We finally point out that the solver of Tang et al.
(2016c) is specifically tailored for problems with binary leader variables and with the zero-sum
problem structure, whereas our solver handles these instances as general bilevel problems and does
not explicitly exploit these properties.
Table 5 Results for the instance sets INTER-KP2 (left) and INTER-CLIQUE (right). Each row contains average
results for ten instances. All instances are solved to proven optimality by MIX++.
Tang et al. (2016c) MIX++
n1 k OPT t[s] BestSol LB #unsol t[s]
20 5 388.5 721.4 388.5 388.5 0 5.420 10 163.7 2992.6 159.9 104.2 3 1.720 15 31.4 129.5 31.4 31.4 0 0.222 6 382.7 1281.2 382.7 141.5 6 10.322 11 161.0 3601.8 162.4 0.0 10 2.322 17 29.2 248.2 29.2 29.2 0 0.225 7 436.2 3601.4 437.2 0.0 10 33.625 13 191.5 3602.3 195.6 0.0 10 8.025 19 41.8 1174.6 41.8 41.8 0 0.428 7 516.1 3601.0 516.5 0.0 10 97.928 14 223.4 3602.5 226.8 0.0 10 22.628 21 46.2 3496.9 46.4 7.0 8 0.530 8 536.3 3601.0 537.4 0.0 10 303.030 15 230.0 3602.3 230.8 0.0 10 31.830 23 47.5 3604.5 48.5 0.0 10 0.6
Tang et al. (2016c) MIX++
ν d OPT t[s] BestSol LB #unsol t[s]
8 0.7 2.2 373.0 2.2 2.2 0 0.18 0.9 3.0 3600.0 3.0 0.0 10 0.2
10 0.7 2.9 3600.1 3.0 0.0 10 0.310 0.9 3.0 3600.2 4.0 0.0 10 0.712 0.7 3.0 3600.3 3.6 0.0 10 0.812 0.9 3.0 3600.4 5.0 0.0 10 1.915 0.7 3.0 3600.3 4.6 0.0 10 2.215 0.9 3.0 3600.2 6.3 0.0 10 12.6
Instance Set MIPLIB. Table 6 compares MIX++ with the best benchmark from the literature,
namely SEP2 by Fischetti et al. (2016b), on the very hard MIPLIB class. Recall that this class con-
tains some instances with up to 80 000 HPR variables, hence in many cases the optimal solutions
are still unknown. For the two settings and for each instance, Table 6 reports the best obtained
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 35
upper bound (BestSol), the best obtained lower bound (LB), the final percentage gap, the com-
puting time (in seconds), and the number of B&C nodes. Whereas SEP2 solves 20 instances of this
class to optimality, MIX++ manages to provide optimal solutions in 27 cases. Furthermore, for all
but three instances, the final lower bound is strictly (and, very often, significantly) better by using
our new MIX++ algorithm.
8. Conclusions
Mixed-Integer Bilevel Linear Programs are very important and challenging optimization models
arising in many important practical contexts, including pricing mechanisms in the energy sec-
tor, airline and telecommunication industry, transportation networks, optimal expansion of gas
networks, critical infrastructure defense, and machine learning.
In the present paper we have presented a new branch-and-cut algorithm for the exact solution
of such problems. We have described an effective bilevel-specific preprocessing procedure. In addi-
tion, new classes of valid linear inequalities have been introduced, along with the corresponding
separation procedures.
The computational performance of our method has been evaluated on a very large set of test
problems from the literature and on randomly generated instances—with its 850+ instances of
various types, our computational study is by far the most extensive ever reported in the literature.
Computational results showed that our new algorithm consistently outperforms (often by a large
margin) all alternative state-of-the-art methods for MIBLPs from the literature that we are aware
of, including methods which exploit problem specific information for special instance classes. In
addition, the new algorithm was also able to provide the optimal solution for hundreds of open
instances from the recent literature.
Our solver has been made available online, for research purposes, at (Fischetti et al. 2017).
Future work should investigate how our approach can be specialized to better deal with bilevel
optimization problems with a specific structure—notably, interdiction-type problems. The exten-
sion of our solution scheme to more general (possibly nonlinear) settings is also an interesting topic
for future research.
Appendix A: Overall Branch-and-Bound Scheme
For the sake of self completeness, we next outline the B&B scheme for MIBLPs presented in
(Fischetti et al. 2016b), whose convergence requires Assumption 1. To simplify the presentation,
we also assume that Assumption 2 holds true, and refer the reader to (Fischetti et al. 2016b, Sect.
3.1) for a treatment of the general case.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs36 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Table 6 Results for instance set MIPLIB. ∗Instances solved to proven optimality by MIX++ using a more
aggressive setting: air03-0.1 (optimal value 376936), p0201-0.1 (opt. 12225), and p0282-0.5 (opt. 272659).
SEP2 MIX++
instance BestSol LB %gap time [s] nodes BestSol LB %gap time [s] nodes
air03-0.1 ∗ 382822 343658.2857 10.23 3600 146125 379800 344940.6202 9.18 3600 92677air03-0.5 505172 344292.2835 31.85 3600 85478 512698 360653.0000 29.66 3600 76005air03-0.9 823130 344977.6032 58.09 3600 44697 770100 358130.7506 53.50 3600 42757air04-0.1 56563 56150.9887 0.73 3600 55921 56399 56291.5472 0.19 3600 61419air04-0.5 60131 56152.5000 6.62 3600 35826 60076 56224.6292 6.41 3600 33459air04-0.9 84993 55961.5987 34.16 3600 3752 73759 56035.8472 24.03 3600 6658air05-0.1 26801 26472.0000 1.23 3600 101047 26577 26577.0000 0.00 401 10168air05-0.5 32497 26448.1580 18.61 3600 92234 31290 26469.7692 15.41 3600 75980air05-0.9 44567 26358.2362 40.86 3600 82050 40558 26350.2340 35.03 3600 63300cap6000-0.1 - -2451433.7522 - 3600 1980 -1967015 -1967015.0000 0.00 587 48281cap6000-0.5 - -2451320.1481 - 3600 1481 - -2400881.8508 - 3600 1115cap6000-0.9 -259599 -2449416.5638 843.54 3600 9709 - -2372513.7387 - 3600 328enigma-0.1 0 0.0000 0.00 0 990 0 0.0000 0.00 0 739enigma-0.5 0 0.0000 0.00 4 13842 0 0.0000 0.00 6 10531enigma-0.9 0 0.0000 0.00 46 2670 0 0.0000 0.00 186 2966fast0507-0.1 12562 172.3615 98.63 3600 604 12484 12484.0000 0.00 2 0fast0507-0.5 61516 173.5238 99.72 3600 7767 61439 61439.0000 0.00 2 0fast0507-0.9 109916 109916.0000 0.00 8 2 109916 109916.0000 0.00 1 0l152lav-0.1 4722 4722.0000 0.00 2 367 4722 4722.0000 0.00 2 363l152lav-0.5 4866 4760.4318 2.17 3600 311915 4868 4758.5000 2.25 3600 258223l152lav-0.9 5090 4789.6571 5.90 3600 211309 5072 4785.3277 5.65 3600 171722lseu-0.1 1120 1120.0000 0.00 0 15 1120 1120.0000 0.00 0 19lseu-0.5 2525 1154.0895 54.29 3600 13333 2313 2036.3864 11.96 3600 12840lseu-0.9 5838 5838.0000 0.00 24 299 5838 5838.0000 0.00 65 357mitre-0.1 122310 115155.2394 5.85 3600 20791 122235 115310.6145 5.66 3600 41872mitre-0.5 146730 115155.0000 21.52 3600 15611 - 115492.2852 - 3600 19004mitre-0.9 168885 115155.9467 31.81 3600 13066 - 115493.3824 - 3600 10099mod010-0.1 6554 6554.0000 0.00 8 739 6554 6554.0000 0.00 4 9mod010-0.5 6692 6551.2005 2.10 3600 117241 6618 6573.4891 0.67 3600 164755mod010-0.9 7448 6554.2000 12.00 3600 158667 7355 6565.6667 10.73 3600 111883nw04-0.1 17066 17066.0000 0.00 820 2884 17066 17066.0000 0.00 1140 2842nw04-0.5 23914 16985.0000 28.97 3600 18519 24100 16689.4706 30.75 3600 8472nw04-0.9 43374 18271.4453 57.87 3600 12282 52290 18241.2202 65.12 3600 6631p0033-0.1 3089 3089.0000 0.00 0 0 3089 3089.0000 0.00 0 0p0033-0.5 3095 3095.0000 0.00 0 2 3095 3095.0000 0.00 0 0p0033-0.9 4679 4679.0000 0.00 0 7 4679 4679.0000 0.00 0 6p0201-0.1 ∗ 12465 7793.2074 37.48 3600 5092 12555 9724.8337 22.54 3600 5837p0201-0.5 13650 11615.0000 14.91 3600 649100 13635 13635.0000 0.00 1113 71052p0201-0.9 15025 15025.0000 0.00 1 150 15025 15025.0000 0.00 1 157p0282-0.1 260785 258489.8687 0.88 3600 371989 260781 260781.0000 0.00 4 272p0282-0.5 ∗ 273069 258437.0000 5.36 3600 998732 272659 267014.5318 2.07 3600 120899p0282-0.9 627411 285137.0000 54.55 3600 2075980 616034 398553.0624 35.30 3600 175290p0548-0.1 11301 8691.0000 23.10 3600 54071 11051 9115.1458 17.52 3600 102504p0548-0.5 22197 8701.0000 60.80 3600 5121 - 11358.4606 - 3600 11943p0548-0.9 49235 16109.8084 67.28 3600 293986 49509 19026.7330 61.57 3600 17003p2756-0.1 14444 3124.0000 78.37 3600 36718 12862 3338.0000 74.05 3600 37599p2756-0.5 23565 3124.0000 86.74 3600 58203 25384 4077.6628 83.94 3600 18777p2756-0.9 35087 3124.0000 91.10 3600 13687 33623 4685.3819 86.06 3600 9263seymour-0.1 486 413.8447 14.85 3600 231 476 469.9485 1.27 3600 48178seymour-0.5 836 414.0236 50.48 3600 564 807 807.0000 0.00 2 18seymour-0.9 1251 1251.0000 0.00 9 2 1251 1251.0000 0.00 1 0stein27-0.1 18 18.0000 0.00 22 983 18 18.0000 0.00 0 528stein27-0.5 19 19.0000 0.00 7 336 19 19.0000 0.00 0 5stein27-0.9 24 24.0000 0.00 0 0 24 24.0000 0.00 0 0stein45-0.1 30 30.0000 0.00 1899 12549 30 30.0000 0.00 3 2999stein45-0.5 32 32.0000 0.00 658 18613 32 32.0000 0.00 0 14stein45-0.9 40 40.0000 0.00 0 0 40 40.0000 0.00 0 0
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 37
Algorithm 2: A basic branch-and-bound scheme for MIBLP
Input : A MIBLP instance satisfying Assumptions 1 and 2;
Output: An optimal MIBLP solution.
1 Apply a standard LP-based B&B to HPR, branching as customary on integer-constrained
variables xj and yj that are fractional at the optimal LP solution; incumbent update is
instead inhibited as it requires the bilevel-specific check described below;
2 for each unfathomed B&B node where standard branching cannot be performed do3 Let (x∗, y∗) be the integer HPR solution at the current node;
4 Compute Φ(x∗) by solving the follower MILP for x= x∗;
5 if dTy∗ ≤Φ(x∗) then6 The current solution (x∗, y∗) is bilevel feasible: update the incumbent and fathom
the current node7 else8 if not all variables xj with j ∈ JF are fixed by branching then9 Branch on any xj (j ∈ JF ) not fixed by branching yet, even if x∗j is integer, so as
to reduce its domain in both child nodes10 else11 let (x, y) be an optimal solution of the HPR at the current node amended by
the additional restriction dTy≤Φ(x∗);
12 Possibly update the incumbent with (x, y), and fathom the current node13 end14 end15 end
The overall B&B scheme is sketched in Algorithm 2, which is a simplified version of Algorithm 2
in (Fischetti et al. 2016b). The approach is an extension of the classical B&B approach for MILP,
so we only discuss its bilevel-specific steps here.
Although not strictly required, and contrarily to the B&B proposal of Moore and Bard (1990),
branching on y variables is not forbidden in our B&B scheme. Correctness of this branching scheme
derives from the fact that, though bounds on the y variables may be modified by branching, the
original ones are used in the follower problem to compute Φ(x∗) at the current node, i.e., the
function that computes Φ(·) is completely blind with respect to branching.
Lines 2-15 of Algorithm 2 handle the “problematic” B&B nodes for which standard branching
on a fractional variable is not possible. Because of the boundedness assumption, this may only
happen because integrality requirements are met by the LP solution (x∗, y∗) at the given node.
If this solution is bilevel feasible, we just update the incumbent and fathom the node (Line 6).
Otherwise, we try and branch on an integer variable xj with j ∈ JF (Line 8) with the aim of
reducing its feasibility domain. If this is not possible because all xj with j ∈ JF have been already
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs38 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
fixed by branching, we know that Φ(x) = Φ(x∗) is a constant for all bilevel-feasible solutions of the
current node, so at Line 11 we can impose dTy≤Φ(x∗) and solve the resulting HPR by a black-box
MILP solver—alternatively, one could just add the locally-valid cut dTy ≤ Φ(x∗) to the current
HPR, reoptimize it, and continue.
Theorem 7. (Fischetti et al. (2016b)) If the HPR feasible set is bounded and JF ⊆ Jx, Algorithm 2
correctly solves MIBLP in a finite number of iterations.
Proof Finiteness follows immediately from the boundedness assumption, which implies that all
integer variables have finite bounds. As each branching operation strictly reduces the domain of
an integer-constrained variable, a finite number of B&B nodes will therefore be generated—each
node requiring a finite number of operations to be processed. Correctness follows from the fact
that, because of requirement JF ⊆ Jx, Line 11 actually computes the best bilevel-feasible solution
(x, y) for the current node, so the node can be pruned after the incumbent update. �
Acknowledgments
This research was funded by the Vienna Science and Technology Fund (WWTF) through project ICT15-
014. The work of M. Fischetti and M. Monaci was also supported by the University of Padova (Progetto di
Ateneo “Exploiting randomness in Mixed Integer Linear Programming”), and by MiUR, Italy (PRIN project
“Mixed-Integer Nonlinear Optimization: Approaches and Applications”). The work of I. Ljubic and M. Sinnl
was also supported by the Austrian Research Fund (FWF, Project P 26755-N19). Thanks are due to the
Associate Editor and to three anonymous referees for their helpful comments and suggestions.
References
Andersen K, Cornuejols G, Li Y (2005) Split closure and intersection cuts. Mathematical Programming
102(3):457–493.
Andersen K, Louveaux Q, Wolsey L, Weismantel R (2007) Inequalities from two rows of a simplex tableau.
Lecture Notes in Computer Science 4513:1–15, proceedings of IPCO 2007.
Audet C, Haddad J, Savard G (2007) Disjunctive cuts for continuous linear bilevel programming. Optimiza-
tion Letters 1(3):259–267.
Baggio A, Carvalho M, Lodi A, Tramontani A (2016) Multilevel approaches for the critical node problem.
working paper, Ecole Polytechnique de Montreal.
Balas E (1971) Intersection cuts–a new type of cutting planes for integer programming. Operations Research
19(1):19–39.
Balas E (1972) Integer programming and convex analysis: Intersection cuts from outer polars. Mathematical
Programming 2(1):330–382.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 39
Basu A, Bonami P, Cornuejols G, Margot F (2011a) Experiments with two-row cuts from degenerate
tableaux. INFORMS Journal on Computing 23(4):578–590.
Basu A, Bonami P, Cornuejols G, Margot F (2011b) On the relative strength of split, triangle and quadri-
lateral cuts. Mathematical Programming 126(2):281–314.
Bhattacharjee B, Green WH, Barton PI (2005a) Interval methods for semi-infinite programs. Computational
Optimization and applications 30(1):63–93.
Bhattacharjee B, Lemonidis P, Green Jr WH, Barton PI (2005b) Global solution of semi-infinite programs.
Mathematical Programming 103(2):283–307.
Bixby RE, Ceria S, McZeal CM, Savelsbergh MWP (1998) An updated mixed integer programming library:
MIPLIB 3.0. Optima 58:12–15.
Bracken J, McGill J (1973) Mathematical programs with optimization problems in the constraints. Operations
Research 21:37–44.
Brotcorne L, Labbe M, Marcotte P, Savard G (2008) Joint design and pricing on a network. Operations
Research 56(5):1104–1115.
Brown G, Carlyle M, Salmeron J, Wood K (2006) Defending critical infrastructure. Interfaces 36(6):530–544.
Caramia M, Mari R (2015) Enhanced exact algorithms for discrete bilevel linear problems. Optimization
Letters 9(7):1447–1468.
Conforti M, Cornuejols G, Zambelli G (2010) Equivalence between intersection cuts and the corner polyhe-
dron. Operations Research Letters 38(3):153–155.
Conforti M, Cornuejols G, Zambelli G (2014) Integer Programming (Springer International Publishing).
DeNegre S (2011) Interdiction and Discrete Bilevel Linear Programming. Ph.D. thesis, Lehigh University.
DeNegre S, Ralphs TK (2009) A branch-and-cut algorithm for integer bilevel linear programs. Operations
Research and Cyber-Infrastructure, 65–78 (Springer).
Dey SS, Lodi A, Tramontani A, Wolsey LA (2014) On the practical strength of two-row tableau cuts.
INFORMS Journal on Computing 26(2):222–237.
Dolan ED, More J (2002) Benchmarking optimization software with performance profiles. Mathematical
Programming 91(2):201–213.
Faısca NP, Dua V, Rustem B, Saraiva PM, Pistikopoulos EN (2007) Parametric global optimisation for
bilevel programming. Journal of Global Optimization 38(4):609–623.
Fischetti M, Ljubic I, Monaci M, Sinnl M (2016a) Appendix of: A new general-purpose algorithm for mixed-
integer bilevel linear programs URL http://www.dei.unipd.it/~fisch/appendix.pdf.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPs40 Article submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3
Fischetti M, Ljubic I, Monaci M, Sinnl M (2016b) Intersection cuts for bilevel optimization. Louveaux Q,
Skutella M, eds., Integer Programming and Combinatorial Optimization: 18th International Confer-
ence, IPCO 2016, Liege, Belgium, June 1-3, 2016, Proceedings, Springer International Publishing, 77–
88 (extended version submitted for publication), URL http://www.dei.unipd.it/~fisch/papers/
intersection_cuts_for_bilevel_optimization.pdf.
Fischetti M, Ljubic I, Monaci M, Sinnl M (2017) Instances and solver software for Mixed-Integer Bilevel
Linear Problems. https://msinnl.github.io/pages/bilevel.html, accessed in March 2017.
Floudas CA, Stein O (2007) The adaptive convexification algorithm: a feasible point method for semi-infinite
programming. SIAM Journal on Optimization 18(4):1187–1208.
Garcia-Herreros P, Zhang L, Misra P, Arslan E, Mehta S, Grossmann IE (2016) Mixed-integer bilevel opti-
mization for capacity planning with rational markets. Computers & Chemical Engineering 86:33 –
47.
Gilbert F, Marcotte P, Savard G (2015) A numerical study of the logit network pricing problem. Transporta-
tion Science 49(3):706–719.
Glover F (1974) Polyhedral convexity cuts and negative edge extensions. Zeitschrift fur Operations Research
18(5):181–186.
Glover F, Klingman D (1976) Improved convexity cuts for lattice point problems. Journal of Optimization
Theory and Applications 19(2):283–291.
Gumus ZH, Floudas CA (2005) Global optimization of mixed-integer bilevel programming problems. Com-
putational Management Science 2(3):181–212.
Jeroslow RG (1985) The polynomial hierarchy and a simple model for competitive analysis. Mathematical
Programming 32(2):146–164.
Kleniati PM, Adjiman CS (2015) A generalization of the branch-and-sandwich algorithm: From continuous
to mixed-integer nonlinear bilevel problems. Computers & Chemical Engineering 72:373 – 386.
Koppe M, Queyranne M, Ryan CT (2010) Parametric integer programming algorithm for bilevel mixed
integer programs. Journal of Optimization Theory and Applications 146(1):137–150.
Kunisch K, Pock T (2013) A bilevel optimization approach for parameter learning in variational models.
SIAM Journal on Imaging Sciences 6(2):938–983.
Labbe M, Marcotte P, Savard G (1998) A bilevel model of taxation and its application to optimal highway
pricing. Management Science 44(12):1608–1622.
Loridan P, Morgan J (1996) Weak via strong Stackelberg problem: new results. Journal of Global Optimiza-
tion 8:263–297.
Mitsos A (2010) Global solution of nonlinear mixed-integer bilevel programs. Journal of Global Optimization
47(4):557–582.
M. Fischetti, I. Ljubic, M. Monaci, M. Sinnl: A new algorithm for MIBLPsArticle submitted to Operations Research; manuscript no. OPRE-2016-07-379.R3 41
Mitsos A, Lemonidis P, Lee CK, Barton PI (2008) Relaxation-based bounds for semi-infinite programs. SIAM
Journal on Optimization 19(1):77–113.
Moore J, Bard J (1990) The mixed integer linear bilevel programming problem. Operations Research
38(5):911–921.
Outrata J (1990) On the numerical solution of a class of Stackelberg problems. ZOR - Methods and Models
of Operations Research 34:255–277.
Ralphs TK (2015) MibS. https://github.com/tkralphs/MibS, accessed in February 2016.
Ralphs TK, Adams E (2016) Bilevel instance library. http://coral.ise.lehigh.edu/data-sets/
bilevel-instances/, accessed in February 2016.
Scaparra MP, Church RL (2008) A bilevel mixed-integer program for critical infrastructure protection plan-
ning. Computers & Operations Research 35(6):1905 – 1923.
Tang Y, Richard JPP, Smith JC (2016a) Bilevel clique instances. http://people.clemson.edu/~jcsmith/
Test_Instances_files/BCPIns.zip, accessed in May 2016.
Tang Y, Richard JPP, Smith JC (2016b) Bilevel knapsack instances. http://people.clemson.edu/
~jcsmith/Test_Instances_files/BKPIns.zip, accessed in May 2016.
Tang Y, Richard JPP, Smith JC (2016c) A class of algorithms for mixed-integer bilevel min–max optimiza-
tion. Journal of Global Optimization 66(2):225–262.
Tsoukalas A, Rustem B, Pistikopoulos EN (2009) A global optimization algorithm for generalized semi-
infinite, continuous minimax with coupled constraints and bi-level problems. Journal of Global Opti-
mization 44(2):235–250.
Wood RK (2010) Bilevel Network Interdiction Models: Formulations and Solutions (John Wiley & Sons,
Inc.).
Xu P (2012) Three essays on bilevel optimization algorithms and applications. Ph.D. thesis, Iowa State
University.
Xu P, Wang L (2014a) BMILP Library. http://lzwang.public.iastate.edu/bmilplib.html, accessed in
October 2015.
Xu P, Wang L (2014b) An exact algorithm for the bilevel mixed integer linear programming problem under
three simplifying assumptions. Computers & Operations Research 41:309–318.
Zugno M, Morales JM, Pinson P, Madsen H (2013) A bilevel model for electricity retailers’ participation in
a demand response market environment. Energy Economics 36:182–197.