## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Chris Johnson

1 Background

1.1 Integer Programming

Given an objective function of n variables x

1

, . . . , x

n

of the form

f(x

1

, . . . , x

n

) =

n

i=1

a

i

x

i

+ c

and a set of constraints that can be written in the form Ax ≤ b (where x is the column

vector of the variables x

i

, . . . , x

n

), the problem of searching for a minimum (or maximum)

of f(x

1

, . . . , x

n

) is known as a linear program, and can be solved eﬃciently using algorithms

such as Dantzig’s simplex. However, if we were to also impose that each x

i

must be an integer

value, we stumble into the world of more diﬃcult problems known as integer programs [4].

1.2 Computational Complexity

The relative eﬃciency of any algorithm is of general interest to any user of that algorithm; we

all want to have some idea how long it will take our programs to run. Computer scientists,

computational complexity theorists in particular, have devised formal ways of measuring the

amount of time required by an algorithm as a function of the size of the algorithm’s input.

For example, searching for a particular value in a set of sorted data can be done in O(log n)

time, meaning the number of steps has an upper-bound on the order of the logarithm of the

number of items in the set.

Though the eﬃciency of an algorithm on a “realistic” model of computation is of primary

interest to most people, computer scientists are also often concerned with how eﬃciently an

algorithm may execute on other types of computers. For example, computers that can per-

form some constant number of operations at each time step are referred to as deterministic,

while those that can perform an abritrary number of operations at each step are referred to

as non-deterministic. All real computers are deterministic, though non-deterministic models

of computation are of interest, mainly due to the improvement in running time of algorithms

with such models.

The set of all decision problems (problems with “yes or no” answers) that can be solved

in polynomial time on a deterministic machine is referred to as the class {. The class of

decision problems that can be solved in polynomial time on a non-deterministic is known

as ^{. Obviously { ⊆ ^{ (any problem that can be solved in polynomial time on a

1

deterministic machine can be solved in polynomial time on a non-deterministic machine),

though whether { ⊂ ^{ or { = ^{ is still an open question.

Given that it is not yet clear if { = ^{ or not, complexity theorists have formulated

another class of the “hardest” problems in ^{ known as ^{-complete. These are problems

in ^{ that every other problem in ^{ (and thus every problem in {) can be transformed

into in (deterministic) polynomial time [2]. Classic examples of the such problems include

the satisﬁability problem, and (the decision problem version of) the travelling salesman

problem, while more modern examples include the decision problem versions of games such

as minesweeper and Tetris.

Of course, there are problems that are even harder than the problems in ^{. Games

such as chess and go, for instance, are known to reside in cA{T 1´c, meaning they require

exponential time on a deterministic machine. There is, however, a special class of problems

that are at least as hard any problem in ^{.

Suppose we have a problem Π that may or may not be in ^{. If every problem in ^{

can be transformed into Π in polynomial time, then we say that Π is ^{-hard. It is in this

sense we mean that Π is at least as hard as any problem in ^{ [2].

2 Why is Integer Programming ^{-Hard?

2.1 The Satisﬁability Problem as an Integer Program

The original ^{-complete problem described by Stephen Cook is known as the satisﬁability

problem, which asks us if there is any combination of boolean variables such that a given

boolean formula is true [1]. The following conventions allow us to describe the satisﬁability

problem as an integer program [4].

The value one will stand for true, and the value zero will stand for false. Binary AND

is represented by multiplication, and binary OR is represented by addition. Negation of x,

which we will denote ¯ x, is representated by 1 − x. Our boolean formula will be placed in

conjuctive normal form (clauses of ORs that are ANDed together), which means that using

our representation, the problem has a solution if there is a set of values such that the formula

evaluates to a number that is greater than or equal to one. Furthermore, this implies that

each clause must evaluate to a value that is greater than or equal to one, which we can use

as our constraints. Consider the following formula from [4].

(x

1

∨ x

2

∨ x

3

) ∧ (x

1

∨ ¯ x

2

) ∧ (x

2

∨ ¯ x

3

) ∧ (x

3

∨ ¯ x

1

) ∧ ( ¯ x

1

∨ ¯ x

2

∨ ¯ x

3

)

Using the convention described above, this boolean formula becomes the following arith-

metic formula.

(x

1

+ x

2

+ x

3

) (x

1

+ 1 −x

2

) (x

2

+ 1 −x

3

) (x

3

+ 1 −x

1

) (1 −x

1

+ 1 −x

2

+ 1 −x

3

)

We may now easily convert this to an integer program.

2

maximize y

x

1

+ x

2

+ x

3

≥ y

x

1

+ 1 −x

2

≥ 1

x

2

+ 1 −x

3

≥ 1

x

3

+ 1 −x

1

≥ 1

1 −x

1

+ 1 −x

2

+ 1 −x

3

≥ 1

x

1

, x

2

, x

3

≤ 1

x

1

, x

2

, x

3

≥ 0

x

1

, x

2

, x

3

∈ Z

The associated boolean expression has a solution only if after maximization, y ≥ 1.

This special case of integer programming, where our variables are limited to the values

zero and one, is known as 0-1 programming. Obviously, as we have shown an ^{-complete

problem can be reduce to a 0-1 programming problem, we have shown that 0-1 programming

is ^{-hard.

2.2 Equivalence of General Integer Programming and 0-1 Pro-

gramming

We shall now show that the “general” integer programming problem (that is, where our vari-

ables may be any integer) is polynomially equivalent to 0-1 programming. By polynomially

equivalent, we mean a problem of one type may be transformed into an equivalent problem

of the other type in polynomial time [2]. Knowing that these two classes of problems are

polynomially equivalent establishes the fact that if one class of problems is ^{-hard, then

so is the other class. The technique we describe appears in [4].

Note that 0-1 programming is a special case of general integer programming (0-1 program-

ming implies integer programming), so we really only need to show that the other direction

(that integer programming implies 0-1 programming). We will show this by describing how

to rewrite an integer program as a 0-1 program.

Suppose we have an integer program whose feasible region is bounded by M, and let

l = log

2

M|. We can now rewrite each x

j

in the original problem as a set of variables x

j,i

where each x

j,i

∈ Z

2

, as each integer has a unique binary representation. Since x

j

≤ M for

each x

j

we are only concerned with integers between 0 and M, which will require at most l

bits. We then set each x

j,i

to the ith bit of the binary representation of j, so

x

j

=

l

i=0

x

j,i

2

i

.

Thus every integer program can be written as a 0-1 program and vice versa. Since

the satisﬁability problem can be written as a 0-1 program, 0-1 programming is ^{-hard,

but since 0-1 programming and integer programming are polynomially equivalent, integer

programming is also ^{-hard.

3

3 Algorithms for Integer Programming

Given that integer programming is ^{-hard, how can we eﬃciently tackle integer program-

ming problems? There are two approaches we will now consider, both of which approach the

problem the same basic way: we will solve the relaxed version of the problem (that is, the

linear program with the same constraints, but allowing non-integer solutions), and continue

to add constraints until we arrive at an integer solution.

3.1 The Cutting Plane Algorithm

The cutting plane algorithm works by ﬁrst ﬁnding the solution to the relaxed version of the

problem. If the solution we found had non-integer solutions, then we will impose a new

constraint that eliminates the previously found solution, but does not eliminate any feasible

integer solutions, until we arrive at a solution with all integer components [5].

3.2 Branch and Bound

The branch and bound algorithm treats the problem by considering a enumeration tree of

possible integer solutions. Of course, this tree is likely to be too large to the consider each

possible enumeration. Thus, we solve the relaxed version of the problem, each time pruning

possible solutions that either infeasible or non-optimal, based on the solution of the relaxed

problem [3].

Branch and bound builds this enumeration tree by considering subregions of the feasible

region (branching), and then ﬁnding appropriate upper and lower bounds for the optimal

solution within a subregion (bounding). One way of doing this would be to ﬁnd the solution

to the original relaxed problem, say x

0

. If x

0

is not an integer, then we break our original

problem into two subproblems.

In the ﬁrst subproblem we impose the constraints that each x

i

must be less than or equal

to x

0

i

|. In the second subproblem, our constraint is that each x

i

must be greater than or

equal to x

0

i

|+1. We then attempt to solve the relaxed version of these problems, branching

again if need be.

If while solving any of our subproblems we arrive at an integer solution, however, we know

that we will not ﬁnd any better solutions to that subproblem by breaking it up into even

more subproblems. We can then kill the nodes of the enumeration tree that are descendents

of the current node [6].

4 Conclusion

Despite that linear programming can be solved relatively eﬃciently in many cases, it comes

as a bit of a shock that problems can become considerably more diﬃcult by imposing the

constraint that we only consider integer solutions. Despite this, there is no avoiding the

fact that there are applications where non-integer solutions are undesirable, and so we must

consider how to best tackle the problem of integer programming.

4

In this paper we have explained why integer programming is ^{-hard, and is thus

likely to remain intractable for the foreseeable future. We have also brieﬂy discussed two

algorithms that we can use for solving integer programming problems by repeatedly solving

relaxed versions of our original problem. Of course, using either algorithm, we’re repeatedly

solving linear programs, modifying the problem until we arrive at an integer solution.

Either algorithm will eventually ﬁnd the solution to the integer program, but there is no

guarantee on the amount of time it will take to do so. It is possible that we could essentially

build our entire enumeration tree using branch and bound if we do not “luck out” and ﬁnd

integer solutions after the ﬁrst few iterations and can kill oﬀ parts of the tree. Depending

on the “shape” of our feasibility region, the cutting plane algorithm may require numerous

iterations until we’ve imposed enough constraints (cut oﬀ enough of the plane) that we arrive

at an integer solution.

References

[1] Stephen A. Cook. The complexity of theorem-proving procedures. In Proceedings of the

third annual ACM symposium on Theory of Computing, pages 151–158, 1971.

[2] Michael R. Garey and David S. Johnson. Computers and Intractibility: A Guide to the

Theory of NP-Completeness, chapter 2. W. H. Freeman and Company, 1979.

[3] George L. Nemhauser and Laurence A. Wolsey. Integer and Combinatorial Optimization,

chapter 14. John Wiley and Sons, 1988.

[4] Christos H. Papadimitriou and Kenneth Steiglitz. Combinatorial Optimization: Algo-

rithms and Complexity, chapter 13. Dover Publications, 1998.

[5] Christos H. Papadimitriou and Kenneth Steiglitz. Combinatorial Optimization: Algo-

rithms and Complexity, chapter 14. Dover Publications, 1998.

[6] Christos H. Papadimitriou and Kenneth Steiglitz. Combinatorial Optimization: Algo-

rithms and Complexity, chapter 18. Dover Publications, 1998.

5

- Linear Programminguploaded byKannan Govindan
- Homewrokuploaded bySyed Muhammed Alee Kazmi
- Generat Bilbaouploaded byMatemáticas Betanzos
- zimpluploaded byAzdff
- Distributed Decision Making Algouploaded byArchanaMuthusamy
- Csc313 Lecture Complexity(6)uploaded byChristopher Miller
- Linear Programming ChVatAluploaded byzu1234567
- Integer Programming _ Sven O. Krumkeuploaded byroyeh
- Integer Programminguploaded byapi-26143879
- Linear Integer Programming Modelsuploaded bykmamforte
- Integer Programming-wolsey - 经典英文整数规划uploaded byTarique Hasan Khan
- Data Structures and Algorithms in Python - Michael T. Goodrichuploaded byPraneeth Akula Sona
- Chvatal Linear Programminguploaded byPablo Rosenbaum
- Integer Programming Scribduploaded byNavi_85
- NK Landscapes, Problem Difficulty, and Hybrid Evolutionary Algorithmsuploaded byMartin Pelikan
- Near-Optimal Hashing Algorithms for Near Neighbor Problem in High Dimensionsuploaded by.xml
- Common Core Stateuploaded byHeinrichjohannes
- Practice Examuploaded bykhalfan athman
- Vertex Cover to Independent Setuploaded byGaurav Raj
- MELJUN CORTES AUTOMATA THEORY chapter21uploaded byMELJUN CORTES, MBA,MPA
- solve8uploaded byzvisar
- Nathan Ryder- Calculating Knot Polynomialsuploaded bySprite090
- Lecture Notes Algorithmuploaded byAgbajeola Micheal Abiola
- Post Mid ALGOuploaded bywiki.iiest
- DQuploaded byAahitagni Banerji
- (Network Theory and Applications 9) Xiaohua Jia, Xiao-Dong Hu, Ding-Zhu Du (auth.)-Multiwavelength Optical Networks-Springer US (2002).pdfuploaded byAlberto José Escalona Piñero
- 79-314-1-PBuploaded byjohnoftheroad
- Daauploaded byVijaya Kumar
- constrained non linear programminguploaded byajeeta23

- Zero Functional Implies Dense Setuploaded byChris Johnson
- HW07uploaded byChris Johnson
- Practice Testuploaded byChris Johnson
- HW05uploaded byChris Johnson
- HW06uploaded byChris Johnson
- HW01uploaded byChris Johnson
- kerfuploaded byChris Johnson
- Counting Sequencesuploaded byChris Johnson
- Homo Morph Isms of Regular Languagesuploaded byChris Johnson

Read Free for 30 Days

Cancel anytime.

Close Dialog## Are you sure?

This action might not be possible to undo. Are you sure you want to continue?

Loading