NOTICE WARNING CONCERNING COPYRIGHT RESTRICTIONS:
The copyright law of the United States (title 17, U.S. Code) governs the making
of photocopies or other reproductions of copyrighted material. Any copying of this
document without permission of its author may be prohibited by law.
CMU-CS-96-105
Minkowski's Convex Body Theorem and
Integer Programming
Ravi Kannan
Abstract The paper presents an algorithm for solving Integer Program-
ming problems whose running time depends on the number n of variables
in the problem as n°^
n
\ This is done by reducing an n variable problem
to na* problems in n — i variables for some i greater than 1. The factor
of n
5
/
2
"per variable" improves on the best previously known factor which
is exponential in n. Minkowski's Convex Body theorem and other results
from Geometry of Numbers play a crucial role in the algorithm; they are
explained from first principles.
Supported by NSF grant ECS-8418392
Introduction
The Integer Programming (feasibility) Problem is the problem of determining whether
there is a vector of integers satisfying a given system of linear inequalities. In settling an
important open problem, H.W.Lenstra (1981,1983) showed in an elegant way that when n
the number of variables is fixed, there is a polynomial time algorithm to solve this problem.
He accomplishes this by giving a polynomial time algorithm that for any polytope P in Z
n
either finds an integer point (point with all integer coordinates) in P or finds an integer
vector v so that the maximum value of (v,x) and the minimum value of (v,x) over the
polytope P differ by less than c
n
where c is a constant independent of n. Every integer
point must lie on a hyperplane of the form (v,x) = z for some integer 2, and there are at
most c
n
* such hyperplanes intersecting P. It obviously suffices to determine for each such
hyperplane JB", whether H n P contains an integer point. Lenstra uses this to show that
an n variable problem can be reduced to c
n
problems each in n
—
1 variables. This raises
two questions : Can we effectively reduce an n variable problem to polynomially many
n
—
1 variable problems ? Can the reduction be done efficiently so as to achieve a better
complexity for Integer Programming ? Both these questions are answered affirmatively in
this paper.
If an n variable problem is reduced to polynomially many n
—
1 variable problems, the
best complexity we can achieve is n
en
for some constant c, so we are at liberty to take
this amount of time for the reduction to one less variable. Furthermore, the same result
is obviously achieved if we reduce an n variable problem to problems in n
—
i variables
for some i between 1 and n. Indeed, the greater the t the better since then we reduce the
number of variables by a larger amount. This paper presents an algorithm which either
finds an integer point in the given polytope P in Z
n
or finds for some i, 1 < i < n, an
n — i dimensional subspace V with the following property : the number of translates of
V containing integer points that intersect P is at most n*\ Each such translate leads to
a n — i dimensional problem. So, it can be shown that there is a factor of 0(n
5
/
2
) per
variable in the running time. In this sense, it reduces an n variable problem effectively to
0(n
5
/
2
) problems in n
—
1 variables. The algorithm for finding the subspace V uses at most
0(n
n
s) arithmetic operations where s is the length of description of the polytope. The
dependence on n of the complete integer programming algorithm is shown to be O(n
on
).
This paper is the final journal version of the preliminary paper Kannan (1983). Since
the appearance of the preliminary version, Hastad (1985) has observed using results of
Lenstra and Schnorr (1984) that for any polytope P of positive volume in £
n
, if P does
not contain an integer point, then, there exists an integer vector v such that the maximum
and minimum of (v, x) over P differ by at most 0(n
5
/
2
). This is an interesting existence
result. But, there is no finite algorithm known that with P as input either gives us an
integer point in P or the vector v. If we relax the 0(n
5
^
2
) to 0(n
3
), then we can get such an
algorithm using the techniques of this paper ; it uses 0(n
n
s) arithmetic operations. This
gives a way of reducing an n variable Integer Program to 0(n
z
) problems in n
—
1 variables.
However, the resulting algorithm for Integer Programming has, obviously, asymptotically
worse complexity, so it is not presented here.
This paper uses several concepts and results from Geometry of Numbers, the most
crucial of them being Minkowski's convex body theorem. This elegant classical theorem
turns out to be crucial in effectively reducing an n variable problem to polynomially many
n
—
1 variable problems rather than an exponential number of them. Section 1 contains a
brief introduction to Geometry of Numbers to make the paper self-contained for Operations
Researchers and Computer Scientists.
The integer programming algorithm will be presented after two other algorithms : one
for finding the shortest (in Euclidean length) non-zero integer linear combination of a
given set of vectors and the other for finding the integer linear combination of a set of
vectors that is closest (in Euclidean distance) to another given vector. These are called
the Shortest Vector Problem (SVP) and the Closest Vector Problem (CVP) respectively.
The algorithms for both problems take 0(n
n
s) arithmetic operations on n dimensional
problems where s is the length of the input. The algorithm for the SVP is needed as a
subroutine in the integer programming algorithm whereas the algorithm for the CVP is
not directly needed, but has ideas that will be useful in integer programming.
It is well-known that Integer Programming is NP-hard. It has been shown recently
that CVP is NP-hard. At present, it is not known whether SVP is NP-hard or admits a
polynomial time algorithm (or both !). The last section of the paper provides another,
more natural proof that CVP is NP-hard. Further, it relates the complexity of the SVP to
an approximate version of the CVP. It is hoped that this is a beginning towards proving
the NP-hardness of the SVP which remains an important open problem.
Summary of the paper
Operations Researchers are usually interested in solving the Integer Programming Op-
timality problem - i.e., the problem of maximizing a linear function over the set of integer
solutions (solutions with all integer coordinates) to a system of linear inequalities. This
question can be reduced by elementary means to the Integer Programming feasibility ques-
tion which is the problem of determining whether there is an integer point inside a given
polyhedron. This paper deals only with the feasibility question and this will be called the
Integer Programming Problem. Computationally it can be stated as : Given m x n
and m x 1 matrices A and b respectively of integers, find whether there exists an n x 1
vector x of integers satisfying the m inequalities Ax < b. The case of n = 1 can be trivially
solved in polynomial time. For the case of n = 2, Hirschberg and Wong (1976), Kannan
(1980) and Scarf (1981) gave polynomial time algorithms.
Central to H. W.Lenstra's algorithm for general n is an algorithm for finding a "reduced
basis " of a "lattice"(both terms to be explained later). Lenstra's (1981) original basis
reduction algorithm takes polynomial-time only when the number of dimensions is fixed.
After his result, Lovasz devised a basis reduction algorithm which runs in polynomial time
even when n the number of dimensions varies . This algorithm combined with an earlier
result of A.K.Lenstra's (1981) that reduced factoring a polynomial to finding a short vector
2
in a lattice yields a polynomial time algorithm for factoring polynomials over the rationals.
All these ideas were first published in an important paper of Lenstra, Lenstra and Lovasz
(1983).
This paper is referred to henceforth as the LLL paper. Here, the following result
from the LLL paper is used : Given a set of vectors 61,62?
•
•
• &n>
we can find in polynomial
time a nonzero integer linear combination of them whose length is at most 2
n
/
2
times
the length of any (other) nonzero integer linear combination. In addition, we will need a
technical result from H.W.Lenstra's paper which is due to Lovasz. This result is stated in
the section on integer programming.
Section 1 introduces lattices and proves Minkowski's theorem. Section 2 presents an
algorithm for finding a "more reduced basis"
1
of a lattice than the LLL algorithm. While
the end product of this algorithm is better because it is "more reduced", it also takes
more time (0(n
n
s) arithmetic operations) than the LLL algorithm. The first vector of the
"more reduced basis" will be a shortest nonzero vector in the lattice. This solves the SVP
mentioned in the abstract. Section 2 closes with a proof of correctness and a bound on
the number of arithmetic operations. Section 3, the most technical section of the paper,
proves bounds on the size of numbers produced by the algorithm in section 2.
The second major algorithm in the paper is for solving the CVP and is given in section
4.
It uses as a subroutine the algorithm for finding the "more reduced basis". After
these, the algorithm for Integer Programming is given. It performs 0(n2
n
s) arithmetic
operations for an n variable problem and produces numbers with 0(n
2n
s) bits where s is
the length of the input. This is section 5. In a recent paper, Frank and Tardos (1985) show
that all the numbers can be kept polynomially bounded in their number of bits. Their
improvement also brings down the number of arithmetic operations of the algorithm to
0{nl
n
s).
Here is a brief overview of the algorithms : The algorithm for the SVP first solves it
approximately, then enumerates a bounded number of candidates for the shortest nonzero
vector and chooses the best. Minkowski's theorem implies that this set of candidates
suffices. In the algorithm for the CVP and integer programming, the original problem is
transformed so that by appealing to the Minkowski's theorem, the transformed problem
can be reduced to a bounded number of lower dimensional problems.
The last section of the paper contains some results on complexity. The Closest Vector
Problem is shown to be NP-hard by reducing 3-dimensional matching to it. Then the
Yes/No question that corresponds to the Shortest Vector Problem in a natural way is
defined - it is namely the question of whether there is a nonzero integer linear combination
of a set of given vectors of length less than or equal to a given number. The SVP is
shown to be polynomial-time reducible to the Yes/No question. Then using a technique
called "homogenization" from polyhedral theory, it is shown that the problem of solving
the CVP to within a factor of y/n/2 is polynomial-time reducible to the Yes/No question.
I conjecture that this approximate version of the CVP is NP-hard. If the conjecture is
proved , it would be the case that the Yes/No question is NP-complete in the sense of Cook
(1971) and the reduction essentially is a Cook (Turing) reduction rather than a many-one
1
(2.6) gives a definition of the "more reduced basis". It is a very natural concept.
3