¾ If IP is a minimization, the optimal objective value for LR is less than or equal to the optimal objective for IP.
¾ If IP is maximization, the optimal objective value for LR is greater than or equal to that of IP.
¾ If LR is infeasible, then so is IP. ¾ If LR is optimized by integer variables, then that solution is feasible and optimal for
IP. ¾ If the objective function coefficients are integer, then for minimization, the optimal
objective for IP is greater than or equal to the ``round up of the optimal objective for LR. For maximization, the optimal objective for IP is less than or equal to the ``round
down of the optimal objective for LR.
• So solving LR does give some information: it gives a bound on the optimal value, and, if we are lucky, may give the optimal solution to IP. We saw, however, that rounding the solution
of LR will not in general give the optimal solution of IP. In fact, for some problems it is difficult to round and even get a feasible solution. The general methods can be easily
extended to the mixed-integer case http:www.cs.sandia.govoptsurveymip.html
B. Mixed-Integer Programming MIP Problems
• An important special case is a decision variable x1 that is integer with 0 = x1 = 1. This forces x1 to be either 0 or 1 at the solution. Variables like x1, called 0-1 or binary integer
variables, can be used to model yesno decisions, such as whether to build a plant or buy a piece of equipment. However, integer variables make an optimization problem
non-convex ,
and therefore far more difficult to solve. Memory and solution time may rise exponentially as you add more integer variables. Even with highly sophisticated algorithms and modern
supercomputers, there are models of just a few hundred integer variables that have never been solved to optimality. This is because many combinations of specific integer values for
the variables must be tested, and each combination requires the solution of a normal linear or nonlinear optimization problem. The number of combinations can rise exponentially with
the size of the problem
http:www.solver.comprobtype3.htm .
C. Solving MIP Problems
• Since MIP problems are non-convex
, they must be solved by some kind of systematic and potentially exhaustive search. The classic method for solving these problems is called
Branch and Bound http:www.solver.comprobtype3.htm. This method begins by finding the optimal solution to the relaxation of the problem without the integer constraints via
standard linear or nonlinear optimization methods. If in this solution, the decision variables with integer constraints have integer values, then no further work is required. If one or more
integer variables have non-integral solutions, the Branch and Bound method chooses one such variable and branches, creating two new subproblems where the value of that
variable is more tightly constrained. These subproblems are solved and the process is repeated, until a solution that satisfies all of the integer constraints is found.
• According to Trick 1998, they have gone through a number of examples of integer programs. The text gives a few others. A natural question is ``How can we get solutions to
these models? There are two common approaches. Historically, the first method developed was based on cutting planes adding constraints to force integrality. In the last twenty years
or so, however, the most effective technique has been based on dividing the problem into a number of smaller problems in a method called
branch and bound . Recently the last ten
years or so, cutting planes have made a resurgence in the form of facets and polyhedral characterizations. All these approaches involve solving a series of
linear programs. So that
is where we will begin
Universitas Sumatera Utara
1. Branch and Bound
• The most widely used method for solving integer programs is branch and bound. Subproblems are created by restricting the range of the integer variables. For binary
variables, there are only two possible restrictions: setting the variable to 0, or setting the variable to 1. More generally, a variable with lower bound l and upper bound u will be divided
into two problems with ranges l to q and q+1 to u respectively. Lower bounds are provided by the linear-programming relaxation to the problem: keep the objective function and all
constraints, but relax the integrality restrictions to derive a linear program. If the optimal solution to a relaxed problem is coincidentally integral, it is an optimal solution to the
subproblem, and the value can be used to terminate searches of subproblems whose lower bound is higher. See the
branch and bound section of this survey for more details on how
lower bounds, upper bounds, and branching interact. http:www.cs.sandia.govoptsurveymip.html
• According to Trick 1998, they have seen all parts of the branch and bound algorithm. The essence of the algorithm is as follows:
1. Solve the linear relaxation of the problem. If the solution is integer, then we are done. Otherwise create two new subproblems by branching on a fractional variable.
2. A subproblem is not active when any of the following occurs: 1. You used the subproblem to branch on,
2. All variables in the solution are integer, 3. The subproblem is infeasible,
4. You can fathom the subproblem by a bounding argument.
3. Choose an active subproblem and branch on a fractional variable. Repeat until there are no active subproblems.
2. Branch and Cut
• For branch and cut, the lower bound is again provided by the linear-programming LP relaxation of the integer program. The optimal solution to this linear program is at a corner of
the polytope which represents the feasible region the set of all variable settings which satisfy the constraints. If the optimal solution to the LP is not integral, this algorithm
searches for a constraint which is violated by this solution, but is not violated by any optimal integer solutions. This constraint is called a cutting plane. When this constraint is added to
the LP, the old optimal solution is no longer valid, and so the new optimal will be different, potentially providing a better lower bound. Cutting planes are iteratively until either an
integral solution is found or it becomes impossible or too expensive to find another cutting plane. In the latter case, a tradional branch operation is performed and the search for cutting
planes continues on the subproblems.
http:www.cs.sandia.govoptsurveymip.html • There is an alternative to branch and bound called
cutting planes which can also be used to
solve integer programs. The fundamental idea behind cutting planes is to add constraints to a linear program until the optimal basic feasible solution takes on integer values. Of course,
we have to be careful which constraints we add: we would not want to change the problem by adding the constraints. We will add a special type of constraint called a
cut This is
illustrated in Figure 2. A cut relative to a current fractional solution satisfies the following criteria:
1. Every feasible integer solution is feasible for the cut, and 2. The current fractional solution is not feasible for the cut.
Universitas Sumatera Utara
Figure 2.
A cut • There are two ways to generate cuts. The first, called Gomory cuts, generates cuts from any
linear programming tableau. This has the advantage of ``solving any problem but has the disadvantage that the method can be very slow. The second approach is to use the structure
of the problem to generate very good cuts. The approach needs a problem-by-problem analysis, but can provide very efficient solution techniques Trick, 1998.
3. Branch and Price
• This is essentially branch and bound combined with column generation. This method is used to solve integer programs where there are too many variables to represent the problem
explicitly. Thus only the active set of variables are maintained and columns are generated as needed during the solution of the linear program. Column generation techniques are problem
specific and can interact with branching decisions.
D. A Review of MILP Solution Methods
• There are two main methods of solving MILPs in practice, cutting-plane methods and branch-and-bound, plus a hybrid of the two, branch-and-cut. Cutting-plane methods work by
iteratively adding constraints cuts to the set LC or BD, which reduce the size of the feasible region of the LP-relaxation such that the optimum solution of the LP-relaxation
gradually approaches the optimum solution of the original MILP. In the cutting-plane method, infeasibility of the original MILP is detected when an added cut renders the current LP-
relaxation infeasible.
Guieu and
Chinneck 1999. • The well-known branch-and-bound method operates by creating a tree of nodes, each of
which is an LP based on the original LP-relaxation with altered variable bounds. A node is expanded child nodes are derived from it when it has an LP-relaxation that is feasible, but
for which the LP-relaxation optimum point has at least one integer variable that does not have an integral value; one such variable is chosen as the branching variable. Two child
nodes are created by copying all of the constraints in the parent node and then altering the lower bound on the branching variable to create one child node and altering the upper bound
on the branching variable to create the other child node Guieu and Chinneck,1999.
• The bounding function value of intermediate nodes is given by the objective function value of the LP-relaxation. There are various rules for choosing which unexpanded node to choose
next for expansion. The best-bound rule chooses the unexpanded node having the best value of the bounding function anywhere on the branch-and-bound tree. The depth-first rule
chooses the unexpanded node having the best value of the bounding function from among the group of child nodes just created. Leaves of the branch-and-bound tree are reached
when either 1 the optimum solution of the LP-relaxation of a node also satisfies all of the
Universitas Sumatera Utara
integer restrictions in which case it is also a feasible solution for the original MILP, 2 the LP-relaxation of the node is infeasible, or 3 the optimum value attained by the LP-relaxation
of a node is worse than the best known MILP-feasible solution does not occur in infeasible MILPs Guieu and Chinneck,1999.
Figure 3. The branch-and-bound solution of this MILP fails to terminate
• For our purposes, it is important to note that feasibility of a MILP is detected by the branch- and-bound method as soon as the first MILP-feasible node is created. However, infeasibility
is only decided when the tree has been fully expanded and the LP-relaxation of every leaf node proves infeasible. Thus, it is generally much more computationally expensive to
recognize infeasibility than feasibility of a MILP using branch-and-bound. Guieu
and Chinneck 1999.
• In certain cases, the size of the branch-and-bound tree can become very large, possibly exceeding available memory, and in special cases growing infinitely. For example, consider
the MILP in Figure 3 in which both ? and y are nonnegative integer variables. The nonnegativity constraint on y and the two parallel diagonal constraints form a pipeshaped
feasible region. Because the objective is to minimize x + y, the first LP-relaxation optimum solution is at the point marked 1. Because x is not integral at that point, the branch and
bound procedure creates two child nodes; one is infeasible, and the LP-relaxation of the other has an optimum solution at point 2 in Figure 3. Now x has an integral value, but y does
not, leading to the creation of two more child nodes on the branch-and-bound tree. The solution process alternates between x and y as the branching variable, causing the
sequence of solutions to climb the pipe, as shown in Figure 3.
• A branch-and-bound solution of the MILP in Figure 1 will never terminate. It is also easy to construct examples that will terminate, but that require an excessive number of iterations to
do so. For example, imagine that the two diagonal constraints in Figure 3 are angled very slightly towards one another so that they eventually cross at a great distance from the origin.
It may take a great number of iterations before infeasibility can be determined. In the same manner, if the diagonal constraints are very slightly angled away from each other, it may
require a great number of iterations before the first MILP-feasible point is reached Guieu and Chinneck,1999.
• The important point is that a branch-and-bound-based MILP solver may not be able to decide the feasibility status of a MILP in an acceptable number of iterations or within an
acceptable upper limit on available computer memory. The branch-and-cut method incorporates cutting-plane methods into the branch-and-bound framework. The main idea is
to incorporate a cut into a branch-and-bound subproblem under certain conditions. This can speed the recognition of the feasibility status of difficult MILPs such as shown in Figure 1
when the cut either moves the solution into the vicinity of a feasible solution or renders the LP-relaxation infeasible Guieu and Chinneck, 1999.
Universitas Sumatera Utara
E. Application Domains and Software
