You are on page 1of 5

The Complexity of Integer Programming

Chris Johnson

1

Background

1.1 Integer Programming

Given an objective function of n variables x 1 ,

f(x 1 ,

,

x n ) =

, x n of the form

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 ,

of f (x 1 ,

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 difficult problems known as integer programs [4].

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

, x n ) is known as a linear program, and can be solved efficiently using algorithms

1.2 Computational Complexity

The relative efficiency 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 efficiency of an algorithm on a “realistic” model of computation is of primary interest to most people, computer scientists are also often concerned with how efficiently 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 P. The class of decision problems that can be solved in polynomial time on a non-deterministic is known as N P. Obviously P ⊆ N P (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 P ⊂ N P or P = N P is still an open question. Given that it is not yet clear if P = N P or not, complexity theorists have formulated another class of the “hardest” problems in N P known as N P-complete. These are problems in N P that every other problem in N P (and thus every problem in P) can be transformed into in (deterministic) polynomial time [2]. Classic examples of the such problems include the satisfiability 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 N P. Games such as chess and go, for instance, are known to reside in EX PT IME, 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 N P. Suppose we have a problem Π that may or may not be in N P . If every problem in N P can be transformed into Π in polynomial time, then we say that Π is N P -hard. It is in this sense we mean that Π is at least as hard as any problem in N P [2].

2 Why is Integer Programming N P-Hard?

2.1 The Satisfiability Problem as an Integer Program

The original N P -complete problem described by Stephen Cook is known as the satisfiability 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 satisfiability 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 N P -complete problem can be reduce to a 0-1 programming problem, we have shown that 0-1 programming is N P-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 N P-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 satisfiability problem can be written as a 0-1 program, 0-1 programming is N P-hard, but since 0-1 programming and integer programming are polynomially equivalent, integer programming is also N P-hard.

3

3

Algorithms for Integer Programming

Given that integer programming is N P -hard, how can we efficiently 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 first finding 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 finding appropriate upper and lower bounds for the optimal solution within a subregion (bounding). One way of doing this would be to find 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 first subproblem we impose the constraints that each x i must be less than or equal

0 i . In the second subproblem, our constraint is that each x i must be greater than or

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

equal to x

to x

again if need be. If while solving any of our subproblems we arrive at an integer solution, however, we know that we will not find 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 efficiently in many cases, it comes as a bit of a shock that problems can become considerably more difficult 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 N P -hard, and is thus likely to remain intractable for the foreseeable future. We have also briefly 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 find 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 find integer solutions after the first few iterations and can kill off 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 off 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