Integer Programming

Taxonomy and Defintions

 Linear Integer Programs
 Linear programs where variables must
have integer variables
 Linear programs where some of the
variables only are required to have
integer variables  Mixed Integer
Programs (MIP)
 Linear programs that contain only binary
variables  Binary Integer Programs (BIP)
 Non-linear Integer Programs
 Example
 The California Manufacturing Company is
considering expansion by building a new
factory in either LA or SF, or in both cities.
It is also considering building at most one
new warehouse but choice of location is
restricted to a city where a new factory is
being built.

 The objective is to find the feasible

combination of alternatives that maximizes
the net present value (total profitability
considering the time value of money).
Data for Example
BIP Model
1 if decision j is yes,
Let X j  ( j 1,2,3,4)
0 if decision j is no,
Z total net present value of these decisions
Maximize Z 9 X 1  5 X 2  6 X 3  4 X 4
Subject to
! limit on capital available for investment
6 X 1  3 X 2  5 X 3  2 X 4 10
! company wants at most 1 warehouse
X 3  X 4 1
! build a warehouse only if a factory is built at that location
X 3 X1
X 4 X 2
Software for Solving IPs
 LINDO and LINGO can be used to solve
pure or mixed IP or BIP
 In LINDO, add after END statement

GIN X ; if X is integer

INTEGER X ; if X is binary

GIN n ; first n variables are integer

variables
 In LINGO

@BIN() ; variable inside () is binary

@GIN() ; variable inside () is integer
Some BIP Applications
 Capital budgeting with fixed investment
proposal
 Site selection
 Designing a production & Distribution
Network
 Dispatching shipments
 Scheduling interrelated activities
 Scheduling asset divestitures
 Airline Applications
Innovative Uses of Binary
Var.
 Binary variables are typically used to
model decisions of the type yes-no
 They could also be used to model
combinatorial relationships by
expressing such relationships in terms
of questions that must be answered by
yes or no.
 This is done by introducing auxiliary
variables to model these choices.
Innovative Uses of Binary
Var.
 Modeling Either-Or constraints

 Modeling K out of N constraints must

hold

 Functions with N possible values

 The Fixed-Charge problem

Modeling Either-Or
Constraints
 Consider the case where a choice can
be made between 2 constraints where
only one of them must hold and the
other one may or may not hold
 For example, one of the requirements
in the overall problem is that:
Either 3 X 1  2 X 2 18
or X 1  4 X 2 16
Cont’d
 We can model this case as:

3 X 1  2 X 2 18
either 
 X 1  4 X 2 16  M
3 X 1  2 X 2 18  M
or 
 X 1  4 X 2 16
Where M is very large

 By adding M to the constraint, we eliminated it, i.e.,

made it always applicable
Cont’d
 Equivalently we can write the constraints as follows:

3 X 1  2 X 2 18  My

 X 1  4 X 2 16  M (1  y )
Where y is an auxiliary variable

 This formulation guarantees that one of the original

constraints must hold while the other is in effect
eliminated
 K out of N constraints must
hold
 Consider the case where we have a set
of N possible constraints such that only
K of these constraints must hold (K<N)

 Part of the optimization problem is to

choose the combination of K constraints
that permits the objective function to
reach its best possible value
Cont’d
Let the following denote these constraints
f1 X 1 , X 2 ,  , X n  d1
f 2 X 1 , X 2 ,  , X n  d 2

f N X 1 , X 2 ,  , X n  d N
Cont’d
Then applying the same logic as before yields
f1 X 1 , X 2 ,  , X n  d1  My1
f 2 X 1 , X 2 ,  , X n  d 2  My2

f N X 1 , X 2 ,  , X n  d N  My N
N

y
i 1
i N  K

yi is binary for i 1,  , N and M is very large

 Functions with N Possible
Values
 Consider the situation where a
function is required to take on any
one of N given values

f X 1 , X 2 ,  , X n  d1 or d 2 or ... d N
where
f X 1 , X 2 ,  , X n  could be equal to a Xj j or  X j
j j
Functions with N possible
values
 This general case can be modeled
as
N
f X 1 , X 2 ,  , X n   d i yi
i 1
N
0
y i 1 and yi  ; i 1,  , N
i 1
 Cont’d
 Example: In the Wyndor Glass Co. problem
considered in LP lectures, the production
capacity at Plant 3 which is 18 could be used
for the production of Product 1 or Product 2 or
left for future products that will be ready for
production soon.

 In order to leave any remaining capacity in

usable blocks, management wants to impose
the restriction that production time used for P1
and P2 be 6, 12, or 18
Example Cont’d
 This constraint is translated as

3 X 1  2 X 2 6 or 12 or 18
 It can be modeled as follows
3 X 1  2 X 2 6 y1  12 y2  18 y3
y1  y2  y3 1
0
yi  ; i 1, 2, 3
1
The Fixed-Charge problem
 It is common to incur a fixed charge or setup
cost when undertaking an activity
 Total cost of the activity is expressed as
k j  c j x j ; if x j  0
f j x j  
0 ; if x j 0
where
x j level of activity j
k j setup cost of activity j
c j cost of each incremental unit of activity j
Cont’d
 To model a problem of the form
Min Z  f1 x1  f 2 x2    f n xn 
Subject to Constra int s
 We use the following transformation
n
Min Z  k j y j  c j x j
j 1

Subject to
Constra int s
1
 if x j  0
y j 
0
 if x j 0
Cont’d
 Furthermore we can rewrite the last
constraint as
n
Min Z  k j y j  c j x j
j 1

Subject to
Constra int s
x j My j
1
y j  ; j 1,  , n
0
Cont’d
 The last constraint will ensure that

 x j  0  y j 1
If 
 x j 0  y j 0
 The last condition is met because the
objective function is a minimization
and the optimal solution will be for yj =
0
Binary Representation of
General Integer Variables
 When the IP contains very few integer
variables it is more convenient to transform
integer variables into binary and solve it using
a BIP algorithm
If 0  x u and x is integer

N
 Then x can be irepresented as binary
x  2 y i

i 0

where N is determined as follows

2 N u 2 N 1
Formulation Examples
 SOUTHWESTERN AIRWAYS needs to assign its crews to
cover all its upcoming flights. We will focus on the
problem of assigning 3 crews based in San Francisco
to the flights listed in the Table shown next. The #s in
the column indicate the order of the flights. Exactly 3
of the sequences need to be chosen (one per crew) in
such a way that every flight is covered.

 The cost of assigning a crew to a particular sequence

is shown at the bottom

 Objective is to minimize the cost of the 3 crew

assignment to cover all flights.

 Note that it is allowed to have more than one crew on

a flight. Extra crew would fly as passengers.
Example Cont’d
Example Cont’d
 Should sequence j be assigned to a crew? (j =
1, 2, …, 12)
 Use 12 binary variables to model these
decisions
1 if sequence j is assigned to a crew
x j 
0 otherwise

 The constraints should ensure that each flight

is covered at least once. For example, consider
the flight SE to LA, there are 5 sequences (6, 9,
10, and 11) that include this flight. Hence, at
least one of these sequences must be chosen.
Example Cont’d
Min Z 2 x1  3 x2  4 x3  6 x4  7 x5  5 x6  7 x7
 8 x8  9 x9  9 x10  8 x11  9 x12
Subject to
x1  x4  x7  x10 1
x2  x5  x8  x11 1
x3  x6  x9  x12 1
x4  x7  x9  x10  x12 1
x1  x6  x10  x11 1
x4  x5  x9 1
x7  x8  x10  x11  x12 1
x2  x4  x5  x9 1
x5  x8  x11 1
x3  x7  x8  x12 1
x6  x9  x10  x11  x12 1
12

x
j 1
j 3
x j is binary, for j 1,2,  ,12
Set Covering Problems
 The previous example illustrates a broader class
of problems called set covering problems

 Strictly, a set covering problem does not include

any other functional constraints such as the last
constraint in the previous example

 It is also sometimes assumed that every

coefficient in the objective function being
minimized equals one else the name weighted
set covering problem
Set Covering problems
 In general terms a set covering problem can be
described as involving a number of potential
activities (such as flight sequences) and
characteristics (such as flights).

 Each activity possesses some but not all of the

characteristics.

 The objective is to determine the least costly

combination of activities that collectively
possess (cover) each characteristic at least
once.
Set Covering Problems
 Let Si be the set of all activities that
possess characteristic I

 At least one member of the set Si must

be included among the chosen
activities
X
jS i
j 1
Set Partitioning Problems
 A related class of problems to the set
covering problems is the set partitioning
problems

 In these problems, exactly one member of

each set Si must be included among the

chosen activities X j 1
jS i

 In the previous example, this means that

each flight must be included exactly once
among the chosen flights
Solving IP Problems
 A BIP problem with n variables has 2n solutions to be
considered (some will be discarded because they violate
the functional constraints)

 Each time n is increased by 1, the number of possible

solutions is doubled

 This pattern is referred to as the exponential growth

of the difficulty of the problem

 Two primary determinants of computational difficulty for

an IP problem are: 1) # of integer variables and 2) any
special structure in the problem
Solving IP Problems
 Performing exhaustive enumeration for BIP problems with a
few dozen variables is therefore not possible even with the
fastest computers today

 Most successful algorithms for IP incorporate the simplex or

dual simplex by relating portions of the IP problem under
consideration to the corresponding LP. The corresponding LP
is normally referred to as the LP relaxation

 In the case, where the optimal solution of the LP relaxation

satisfy the integer restriction of the IP problem, then that
solution is also optimal for the IP problem

 There exist several special types of IP problems for which this

outcome is guaranteed, namely, the minimum cost flow
problem with integer parameters and its special cases
including the transportation, the assignment, and the
maximum flow problem
Solving IP Problems
 For IP problems that are small enough to be
solved to optimality, a number of algorithms is
now available

 The most popular mode for IP algorithms is to

use the branch-and-bound technique and
related techniques to implicitly enumerate the
feasible integer solutions

 For all other IPs, effective heuristic algorithms

(commonly called metaheuristics) exist. Three
prominent types are tabu search, simulated
annealing, and genetic algorithms
Branch-and-Bound technique
for Solving BIP
 Basic concept involved behind this technique is
Divide and Conquer
 Problem is divided into smaller and smaller sub-
problems until these sub-problems can be conquered
 Dividing (Branching) is done by partitioning the set of
feasible solutions into smaller and smaller sets.
 Conquering (Fathoming) is done partially by
bounding how good the solution in subset can be and
then discard the subset if its bound indicate that it
cannot contain the optimal solution of original Pb.
 So 3 steps: branching, bounding, and fathoming
Branch-and-Bound technique
for Solving BIP
 Consider the following BIP
Maximize Z 9 x1  5 x2  6 x3  4 x4
subject to
(1) 6 x1  3x2  5 x3  2 x4 10
(2) x3  x4  1
(3)  x1  x3 0
(4)  x2  x4  0
and
(5) x j is binary, for j 1, 2, 3, 4.
Branching
 When dealing with binary variables, a simple way to
do it is by fixing the value of one of the variables

Subproblem 1

Fix x1 0 so the resulting problem is

Maximize Z 5 x2  6 x3  4 x4
subject to
(1) 3 x2  5 x3  2 x4 10
(2) x3  x4  1
(3) x3 0
(4)  x2  x4  0
(5) x j is binary, for j 2, 3, 4.
Branching Cont’d
Subproblem 2

Fix x1 1 so the resulting problem is

Maximize Z 9  5 x2  6 x3  4 x4
subject to
(1) 3 x2  5 x3  2 x4 4
( 2) x3  x4 1
(3) x3 1
( 4)  x 2  x4 0
(5) x j is binary, for j 2, 3, 4.
Branching Cont’d
 The tree which continues growing branches iteration
by iteration is referred to as the solution tree or
enumeration tree and X1 is the branching variable.
Bounding
 For each subproblem, we need to
obtain a bound on how good its
best feasible solution can be
 The solution of the LP relaxation of
the subproblem can be used as a
bound
 Simplex method is used to solve the
LP relaxation for a quick solution
Bounding Cont’d
 LP relaxation of overall Pb is obtained by
replacing the binary constraint on Xj with
Xj ≥ 0 and Xj ≤ 1 for j=1, 2, 3, 4
 The LP relaxation of overall Pb yields an
optimal solution Z = 16 1/2 and
X1, X 2 , X 3 , X 4  5 / 6, 1, 0, 1
 All feasible sol of the BIP have Z ≤ 16
since they are subset of the feasible sol of
LP relaxation and parameters in Z are
integers
 Hence bound for the whole Pb is Z ≤ 16
Bounding Cont’d
 Bounding Subproblem 1 is obtained by
replacing the binary constraint on Xj
with Xj ≥ 0 and Xj ≤ 1 for j= 2, 3, 4
 The LP relaxation of this Subproblem 1
yields an optimal solution Z = 9 and
X1, X 2 , X 3 , X 4  0, 1, 0, 1
 The LP relaxation of this Subproblem 2
yields an optimal solution Z = 16 1/5
and X1, X 2 , X 3 , X 4  1, 4/5, 0, 4/5
Summary of results for
Bounding
Fathoming
 A subproblem can be conquered
(fathomed) and thereby dismissed
from further consideration in 3
ways:
 Solution is integer  Optimal sol of LP
relaxation is optimal sol of IP problem.
In the case of example, we fathom
subPb 1 and value of is stored as first
incumbent (best sol found so far)
Z* = 9
Fathoming
 Fathom any subPb whose bound ≤ 9 (the
best incumbent) because it cannot have an
optimal solution better than 9
 Fathom if the simplex method applied to the
LP relaxation finds no feasible solution
because this means that the IP doesn’t have
one.
 At every iteration we are retaining only
those subproblems that could possibly
have a feasible solution better than
current incumbent
Solution to Example
Problem
 Summary of Fathoming Tests

A subproblem is fathomed (dismissed from further consideration) if

Test 1 : Its bound Z *
or
Test 2 : Its LP relaxation has no feasible solutions,
or
Test 3 : The optimal solution for its LP relaxation is integer. (If this
solution is better than the incumbent, it becomes the new incumbent,
and test 1 is reapplied to all unfathomed subproblems with the new
larger Z * .)
 Summary of the BIP
Branch-and-Bound Algorithm

Initialization: Set Z*  . Applytheboundingstep,fathomingstep,

andoptimalitytest describedbelowto the wholeproblem.
If not fathomed,classifythisproblemas the oneremaining"
subproblem " for performingthe first fulliterationbelow.

Stepsfor eachiteration:
1.Branching: Amongtheremaining(unfathome d) subproblem
s,
selectthe one thatwas createdmostrecently.(Breaktiesaccording
to whichhas thelargerbound.)Branchfromthenodefor thissubproblem
to createtwo new subproblem s by fixingthenext varia
ble
(thebranchingvariable)at either0 or 1.
 Cont’d
2. Bounding: For eachnew subproblem , obtainits boundapplyingthe
simplexmethodto its LP relaxationandroundingdownthe valueof Z
for theresultingoptimalsolution.
3. Fathoming: For eachnew subproblem , applythe threefathoming
testssummarized above,anddiscardthosesubproblem s thatare
fathomedby anyof the tests.

Optimalitytest : Stopwhenthereareno remainingsubproblem s;

thecurrentincumbentis optimal.Otherwise,returnto performanother
iteration.
Solution Steps of BIP
Example Problem
Solution Steps of BIP
Example Problem
Solution Steps of BIP
Example Problem
Branch-and Bound Technique
for Solving MIP
 Consider the general MIP problem where
some of the variables I of them are restricted
to integer values
n
Maximize Z  c j x j
j 1

Subject to
n

a x
j1
ij j bi , for i 1,2,  , m

x j 0 for j 1,2,  , n
x j is integer, for j 1,2,  , I ; I n
Standard Branch-and-Bound
Algorithm for solving MIP
 The algorithm presented is a basic
algorithm one for solving MIP
 With a variety of refinements this
algorithm provides a standard
approach for MIP
 Structure of this algorithm was first
developed by Dakin based on a
pioneering algorithm by Land and
Doig.
Changes from BIP
Algorithm
 BRANCHING
 The variables considered for
branching are the integer-restricted
variables that have a non-integer
value in the optimal solution of the LP
relaxation of the current subproblem
 The values assigned to the branching
variable for creating the 2 new
subproblems as follows
Cont’d
 Let x j be the current branching
*
x
variable jand let be its noninteger
value in the optimal solution for the
LP relaxation of the current
subproblem
x  greatest integer x
*
j
*
j

 The range of values for the 2 new

subproblems
*
 
are
x  x and x  x  1
j j j  
*
j
Cont’d
 With this branching scheme, the phenomenon
of a recurring branching variable can occur
MIP Branch-and Bound Algorithm
 Intialization:
set Z* = -∞. Apply bounding,
fathoming, and optimality test
described next to the whole problem.
If not fathomed, consider this problem
as the remaining subproblem for the
first full iteration below.
Cont’d
 Steps for each iteration:
1. Branching:
Among unfathomed subproblems, select one
created most recently (break ties by larger bound).
Select the integer-restricted variable with the non-
integer value in the optimal solution of the LP
relaxation of the subproblem.
Let x be this variable andx * be its value in optimal
j j
solution, branch from the node to create 2 new
subproblems by adding the respective constraints

   
x j  x*j and x j  x*j  1
2. Bounding:
For each new subproblem, get its bound by
applying the simplex method or dual simplex when
reoptimizing to its LP relaxation and use the value
of Z as the bound.
Cont’d
 Steps for each iteration:
3. Fathoming:
For each new subproblem apply the three tests
below and discard subproblems that are fathomed
by any of the tests.
Test 1: Its bound ≤ Z*, where Z* is the value of
current incumbent.
Test 2: Its LP relaxation has no feasible solution
Test 3: The optimal solution for its LP relaxation has
integer values for the integer-restricted variables. If
solution is better than the incumbent, it becomes
the new incumbent and test 1 is reapplied to all
unfathomed subproblems with the new larger Z*.

Optimality test:
Stop when no remaining subproblems; the current
incumbent is optimal. Otherwise, perform another
iteration. If no incumbent then problem has no
feasible solution
An Example MIP
 Consider the following MIP problem
Maximize Z 4 x1  2 x2  7 x3  x4
Subject to
x1  5 x3 10
x1  x2  x3 1
6 x1  5 x2 0
 x1  2 x3  2 x4 3
x j 0 for j 1,2,3,4
x j is an integer, for j 1,2,3
Cont’d
 Initialization:
The LP relaxation of the whole problem
yields the optimal solution
( x1 , x2 , x3 , x4 ) ( 5 4 , 3 2 , 7 4 , 0) with Z 14 14
Problem not fathomed cause feasible
non-integer solution was found.
 Iteration 1:

Select X1 as branching variable. X1=5/4

Subproblem 1: original Pb + X1 ≤ 1

Subproblem 2: original Pb + X1 ≥ 2
Cont’d
 Solving the LP relaxations of these 2
subproblems yield no feasible solutions for
subproblem2 and the following for suproblem1
 Bound for subproblem 1 is Z ≤ 14 1/5
Cont’d
 Iteration 2:
 Select X2 as branching variable with X2=6/5
 Subproblem 3: original Pb +X1 ≤ 1+X2 ≤ 1
 Subproblem 4: original Pb +X1 ≤ 1+X2 ≥ 2
 Solve the LP relaxations of the 2 subproblems yield
Cont’d
 Iteration 3:
 Subproblem 3 is selected for next branching because better
bound

Select X1 as branching variable with X1 =5/6

Subproblem 5: original Pb +X1 ≤ 1+X2 ≤ 1 + X1 ≤ 0

Subproblem 6: original Pb +X1 ≤ 1+X2 ≤ 1 + X1 ≥ 1
 Solve the LP relaxations of the 2 subproblems yielded no feasible
solution for 6
Lagrangian Relaxation
 Bounding is usually done by solving a
relaxation of the original problem. Consider
the problem Max Z CX
ST AX b

 A Lagrangian relaxation can be used for this

purpose where the entire set of functional
constraints is deleted and the objective
function becomes
Max Z CX   ( AX  b)
 0
Cont’d
 If X* is an optimal solution for the original Problem its Z ≤
ZR
Z R CX   ( AX  b) CX Z
* * *

Since AX *  b 0

 Hence Solving the lagrangian relaxation provides a valid

bound
 If λ is chosen well, this bound tends to be a reasonably
tight one (at least comparable to bound from LP
relaxation)
 Without functional constraints this relaxation can be
solved extremely quickly
 Drawbacks are that fathoming tests 2 and 3 are not as
powerful
 Two features are sought in finding a relaxation: 1) should
be solved quickly, 2) should provide tight lower bounds
Other Developments in Solving
BIP problems - Background
 Big break-through had come in the 1960 and early
1970s with development and refinement of branch
and bound approach. Relatively small problems
could be solved efficiently (below 100 variables)
 Next breakthrough came in mid-1980s
 Crowder, Johnson, and Padberg (1983, 1985)
presented a new approach for solving pure BIPs
with no apparent special structure and solved up
to 2,756 variables problem
 Van Roy and Wolsey (1987) extended the same
kind of algorithmic approach to solving mixed MIPs
Cont’d
 Hoffman and padberg in 1991 followed up on
the 1983 and 1985 papers by developing
improved techniques for solving pure BIPs.
They reported that the proposed algorithmic
approach, called branch-and-cut algorithm
solved problems with as many as 6,000
variables!
 This approach cannot solve all pure BIPs with
thousand or hundred of variables even. The
large BIP problems solved had very sparse A
matrices (percentage of non-zero coefficients
was less than 5%). This approach depends
heavily on sparsity of A matrix
 The kind of IP techniques refered to before
have been incorporated in IBM’s OSL
(optimization Subroutine Library).
Overview of Branch-and-Cut
Approach for Solving BIPs
 Automatic problem preprocessing
involves a “computer inspection” of
user supplied IP formulation in order
to spot reformulations that makes the
problem easier to solve. This is done
by
 Fixing variables
 Eliminating redundant constraints
 Tightening constraints (coefficient
reduction)
Fixing Variables
 If one value of the variable cannot satisfy a certain
constraint, even when the other variables equal their
best values for trying to satisfy the constraint, then the
variable should be fixed at its other value
 General procedure for ≤ constraint is to identify
variable with largest positive coefficient and if the sum
of that coefficient and any negative coefficients
exceeds the RHS, then the variable should be fixed at
0
 For example:
5 x1  x2  2 x3 2  x1 0 since 5(1)  1(0)  2(1)  2
3 x1  2 x2  1  x1 0 since 3(1)  2(1)   1
and  x2 1 since 3(0)  2(0)   1
Cont’d
 A similar procedure can be used for ≥
constraints as shown
3 x1  x2  2 x3 2  x1 1 since 3(0)  1(1)  2(0)  2

 Fixing one variable can generate a

chain reaction
3 x1  x2  2 x3 2  x1 1
Then x1  x4  x5 1  x4 0 and x5 0
Then  x5  x6 0  x6 0
Eliminating Redundant
Constraints
 A simple way to detect a redundant constraint
can be described as follows
 If a functional constraint satisfies even the most
challenging binary solution, then it has been made
redundant by the binary constraints and can be
eliminated from further consideration. For a ≤
constraint, the most challenging binary solution has
variables equal to 1 when their coefficients are non-
negative and 0 otherwise (values are reversed for a ≥
constraint)
 Example:
3 x1  2 x2 6 is redundant, since 3(1)  2(1) 6
3 x1  2 x2 3 is redundant, since 3(1)  2(0) 3
3 x1  2 x2  3 is redundant, since 3(0)  2(1) -3
Tightening Constraints
 Consider the following problem
Max Z 3 x1  2 x2
ST 2 x1  3 x2 4
and x1 , x2 binary
 This BIP has 3 feasible solutions and the
LP relaxtion has the feasible region and
opt solution shown next
Cont’d
Cont’d
 When the functional constraints is replaced byx1  x2 1
the opt solution of LP relaxation is the opt solution of
BIP
Cont’d
 Procedure for tightening a ≤
constraint
Denote the constraint by a1 x1  a2 x2    an xn b
1. Calculate S sum of the positive a j
2. Identify any a j 0 such that S  b  a j
a. If none, stop; the constraint cannot be tightened further
b. If a j  0, go to step 3
c. If a j  0, go to step 4
3. (a j  0) Calculate a j S  b and b S  a j .
Reset a j a j and b b. Return to step1.
4. (a j  0) Increase a j to a j b  S . Return to step 1.
Example
 Applying this procedure to the functional
constraint2 x1  3x2 4 (a1 2, a2 3, b 4)
1. S=2+3=5
2. a1 satisfies S  b  a1 . Also a2 satisfies S  b  a2 .
Choose a1 arbitrarily.
3. a1 5  4 1 and b 5  2 3, so reset a1 1 and b 3.
The new tighter constraint is x1  3 x2 3 (a1 1, a2 3, b 3)

1. S=1+3=4
2. a2 satisfies S  b  a2 since 4  3  3
3. a2 4  3 1 and b 4  3 1, so reset a2 1 and b 1.
The new tighter constraint is x1  x2 1 (a1 1, a2 1, b 1)
 x2 1
x1 is
Stop after this step. Tightened constraint
Generating Cutting Planes for
Pure BIP
 A cutting plane (or cut) for any IP
problem is a new functional constraint
that reduces the feasible region for the
LP relaxation without eliminating feasible
solutions for the IP problem.
 One way of generating cutting planes is
by applying the procedure described
earlier for tightening bounds
 There are a number of other techniques
that were developed for generating
cutting planes to accelerate a branch-
and-bound algorithm
A Procedure for
Generating Cutting Planes
1. Consider any functional constraint in ≤ form
with only non-negative coefficients
2. Find a group of variables (called a minimum
cover of the constraint) such that
a. The constraint is violated if every variable in the
group equals 1 and all other variables equal 0
b. But the constraint becomes satisfied if the value of
any one of these variables is changed from 1 to 0.
3. By letting N denote the number of variables
in the group, the resulting cutting plane has
the form
Sum of variables in group ≤ N-1
Example
 Applying this procedure to the constraint
6 x1  3 x2  5 x3  2 x4 10
 We note that the group of variables
x1 , x2 , x4  is a minimal cover because
 (1,1,0,1) violates the constraint
 But the constraint becomes satisfied if the value of any
one of these variables is changed from 1 to 0.
 Since N=3 in this case, the resulting cutting plane is
x1  x2  x4 2
 x1 , x3 
This same constraint has a second minimal cover
since (1,0,1,0) violates the constraint but both
(1,0,0,0) satisfy the constraint, hence
x1  x3 1
is another valid cutting plane