Scribd
Upload
4 views7 pages

Advanced Algorithms Lecture 08,0

The document discusses the Interior Point Algorithm for optimizing barrier problems in linear programming, detailing the algorithm's steps and theorems that support its convergence to the p-center. It also introduces network flow problems, highlighting various types such as the shortest path and maximum flow problems, and explains their relationship to linear programming. Finally, it emphasizes the advantages of the Interior Point Method over the ellipsoid algorithm and presents the integrality theorem for flows in network problems.

Uploaded by

mhmad240
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
4 views7 pages

Advanced Algorithms Lecture 08,0

The document discusses the Interior Point Algorithm for optimizing barrier problems in linear programming, detailing the algorithm's steps and theorems that support its convergence to the p-center. It also introduces network flow problems, highlighting various types such as the shortest path and maximum flow problems, and explains their relationship to linear programming. Finally, it emphasizes the advantages of the Interior Point Method over the ellipsoid algorithm and presents the integrality theorem for flows in network problems.

Uploaded by

mhmad240
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

MIT OpenCourseWare

http://ocw.mit.edu

6.854J / 18.415J Advanced Algorithms


Fall 2008
��

For information about citing these materials or our Terms of Use, visit: http://ocw.mit.edu/terms.
18.415/6.854 Advanced Algorithms October 10, 2001

Lecture 8
Lecturer: Michel X. Goernans Scribe: Jelena Spasojevic

Interior Point Algorithm Wrap Up


In last lecture we were discussing the Interior Point Algorithm. Our goal was to optimize barrier
problem BP ( p ) :

min cTx - p C ln x j subject to Ax = b, x >0

To find p-center one had to solve some quadratic constraints, thus the algorithm discussed in class
was using full Newton steps. In this way we get approximate p-center. In order to asses the run
time of algorithm let us take a look at how does our proximity measure, a(x,s, p) change with:
+ +
x e x Ax, s t s As. We proved the following theorem.

Theorem 1 If a(x, s , p ) < a < 1, then

Thus, as a corollary we get:


2 2
a(x, s, p) < -3 +-a ( x + Ax, s + As, p) < ~ ( xS,, p) < -,
3
i.e., proximity measure decreases after the Newton step. Therefore, if we continue this process, we
will converge to the p-center.
However, in order to find the solution of the linear program, we need to find the p-center for p = 0.
Therefore, after each step, we also change the value of p: p e p(1- 0). We showed the following:

Theorem 2 If a(x, s,p) = a and xTs = np, then

Therefore, the algorithm is as follows:

Initialization: Start with (x(O),d o),


p(O))such that i.
do),p(O)) 5 Refer to the handout
to see in more detail how we can do this. The point is that we can choose this starting point
in such a way that p(O) 5 26L,where L is the length of the program.
While p >_ 6 do:
- Find Ax, As by solving the Newton step equations.
- Let x t x + Ax, s t s + As, p t p ( 1 - 8) where 8 = &.
We can prove the following.

Theorem 3 I n the above algorithm, if before the Newton step the centrality measure a is at most
i,then after the Newton step and changing p, we still have o < i.
Proof: If a(x, s, p) 5 i then by Theorem 1:
-:
o(x + Ax, s + As, p) 5 2 1(1/2)2
-1 2 4'
-

Now let us change p t p(1-Q), where 8 = A.Using Theorem 2 we get a(x+Ax, s+As, p(1-8)) 5

What is the number of iterations that we have to make? Suppose we start at p(O) = 26L. After k
iterations we have p 5 (1- Therefore, in order to have p 5 c, we need k = O ( f i ( L +ln a)).
How do we choose c? We know that at any point because of duality gap: xTs = np. Given that
we stop when p < r then we have xTs < nr, i.e., the duality gap is smaller than nr at the end of
the algorithm. The following theorem allows us to stop as soon as duality gap is smaller than &
and take any vertex below as the solution. Suppose that when we stop there are two vertices of the
original linear program for which the above duality gap condition holds. These two vertices, x('),
x ( ~ )both
, satisfy Ax = b, x 2 0.

Theorem 4 If cTx(') # c ~ x ( then


~)

where L is the size of the initial linear program.

Proof: We have that A is a matrix with integer entries and b is a vector with integer entries.
Then we can express:

(-Pl P2 r1 r 2 rn
x(l)= - &)T ) (-,
and x ( ~= -, ..., -),
q ' q ' "" 4 S S S

v i , j : q,s,pi,qj E and q,s,pi,qj 1 zL


by the theorem we had in a previous lecture.
Assume c is a vector with integer entries as well. Then:

lCTX(') - CTx(2)I = - 1 integer - -


integer integer 1 1
4 S
I=[- qs
I>->-.
qs 22L

Now choose c so that nr < 2 ~ This


~ implies
~ k. = O(JiiL). As the number of steps in the ellipsoid
algorithm was O(n2L) we can see that interior algorithm has much smaller number of iterations.
Also, in ellipsoid algorithm we were reducing the volume of the ellipsoid by a small factor. Here there
are tons of small tricks to reduce p well and to start with p that is not so big. One could also do
+ +
x t z 2Ax, s t s 2As to make it more appealing in practice. Often in actual implementations
the number of iterations is independent of the size of the program.
By choosing E so that ne < 2-2L, we know that every vertex below the current solution is an optimum
solution of the linear program. But How do we find such a vertex? In previous lectures we had a
Lemma saying that for every z in a polyhedron P, there is always a vertex of P below it of value
less than it. In fact, the proof of this lemma provides an algorithm for finding such a vertex.
At this moment we stop with linear programming to go on to network flows. To recapitulate we
have seen two main classes of linear programming algorithms:

Ellipsoid: has the advantage that it only requires us to provide a separation subroutine, rather
than listing all the constraints of the linear program.
Interior Point Method: has the advantage that it is much faster than the ellipsoid algorithm.
Variants of this algorithm are actually used in practice.

A major open question in linear programming is if there exists a strongly polynomial time linear
programming algorithm, i.e., one whose running time does not depend on the size of numbers but
only on dimensions n, rn.

Network Flows
A network flow problem that we will consider in more detail is: Given network (graph) and quantity
of flow allowed on each edge (capacity) and cost, our goal is to find a flow of minimum cost that
satisfies some circulation properties (to be defined later). This problem can be seen as a linear
programming problem. However, we will use the structure of this problem to build faster algorithms
and will be able to give a strongly polynomial time algorithm that solves this problem (i.e., its
running time will depend only on the number of edges and vertices in the graph, and not on the
numerical values in the input).

Problems Being Considered in Network Flows


There are many problems that can be considered as Network Flow problems. Here's a list of some
of them:

Shortest path problem


Bipartite matching problem
Maximum flow problem
Minimum-cost flow problem: This problem is more general than the above problems, there
exist a strongly polynomial algorithm for it and we can also reduce other problems to this one.
This is the very reason we will focus on this one.
a Multicommodity flow problem
Notations
We will use directed graph G = (V, E) to represent a network. We will use the Goldberg-Tarjan
notation. Description of our network model follows:

We are given a bi-directed graph G = (V,


E),i.e., for every v,w E V,
E E J (w,v)
(v,w) E E.

On every edge (v,w) E E there is a capacity u(v,


w).(u: E + Z)
On every edge (v,w)E E there is a cost c(v,w)that is anti-symmetric:

c :E + Z, V(v,w)E E : c(v,w)= -c(w,v).

Definition 1 A flow is a function f : E + R that satisfies


1. anti-symmetry: V(v,w)E E : f (v,w)= -f (w,
v), and
w).
2. capacity constraint: V(v,w)E E : f (v,w)5 u(v,

Definition 2 A circulation is a flow f , for which nothing is lost i n the network, i.e., net flow into
every vertex is 0. More formally,

Now the Minimum Cost Circulation problem is to find a circulation which minimizes:

Note that here because of anti-symmetric costs and flows we are counting cost of every edge (if we
see them in an undirected way) exactly twice.
First as exercise convince yourself that this is a linear program. Therefore we can apply linear
programming algorithms we have seen so far. Now let's discuss reductions from other network flow
problems to this problem.

Maximum Flow Problem


Given a directed graph G = (V,
E),two vertices s,t E V ,capacity u : E + N,find a flow f :E 25
that satisfies
V(v,w)E E : 0 5 f (v,w)5 u(v,w) (1)

and maximizes Cv: ( s , u ) E E f ( s ,v). One can prove that maximum flow is equal to the capacity of the

smallest cut (This is known as the Max-Flow-Min-Cut theorem).


The maximum flow problem is a special case of the minimum cost circulation problem. Indeed, given
an instance of the maximum flow problem, add an edge between s and t and define u(t, s) = oo,
U(S,t) = 0, ~ ( tS), = -1 = -c(s, t) and c(v, w) = 0 for all (v, w) # (s, t).
The capacities on the bidirected edge (s, t) is such that f (t, s) 2 0, implying that the flow goes from
t to s. There is a one-to-one correspondence between circulations in this extended graph and flows
in the original graph satisfying all flow conservation constraints in V \ {s,t}. Moreover, the cost of
any circulation in this extended graph is exactly equal to minus the net flow out of s (or into t) in
the original graph. As a result, the maximum flow problem in G is equivalent to the minimum cost
circulation problem in the extended graph.
The following theorem is known as the integrality theorem.

Theorem 5 If all capacities are integers (u : E t+ Z), then there is an optimum flow f whose
values are all integers (f: E e Z
).

To prove this theorem we can use algorithmic or linear programming approaches. We will see the
first proof later on and just to note that main idea for the second one is that one could argue that
vertices of linear program induced by this problem have only integer components.

Bipartite Matching problem


Given an undirected bipartite graph G = (V, E) with bipartition V = AU B , (AnB = 0, E & A x B),
find a maximum cardinality matching, i.e., a set of non-adjacent edges of largest cardinality.
A matching is called perfect iff it covers every vertex exactly once. This problem is a special case of
the maximum flow problem and therefore the minimum cost circulation problem. To transform the
maximum cardinality bipartite matching problem into a maximum flow problem, we

1. direct all the edges from A to B,


2. add a source vertex s, a sink vertex t,
3. add the edges (s, a) for all vertices a E A and the edges ( b , t) for all vertices b E B and
4. define the capacity of all existing edges to be 1 and the capacity of their reverse edges to be 0
(in other words, the flow on the existing edges have a lower bound of 0).

By the integrality theorem, we know that the flow on any existing edge can be assumed to be either
0 or 1. Therefore, to any flow f , there corresponds a matching A4 = {(v, w ) E E : f(v, w) = 1)
whose cardinality is precisely equal to the net amount of flow out of vertex s.
It is also easy to construct from a matching M a flow of value I M I. As a result, any integral flow of
maximum value will correspond to a matching of maximum cardinality.
In fact, the minimum weighted bipartite matching problem is also a special case of the minimum
cost circulation problem. We can modify the above transformation in the following way. Define
the cost of any edge of the original graph to be its original cost and the cost of any new edge to
be 0. Now, we can model three versions of the minimum weighted bipartite matching problem by
appropriately defining the capacities on the edges (t, s) and (s, t) :

1. If ~ ( tS), = n and u(s, t) = -n where n = IAl = IBI, we get the minimum weighted perfect (a
perfect matching is a matching that covers all the vertices) matching.
2. If u(t9s) = n and u(s9t ) = 0, we obtain the minimum weighted matching.
3. If u(t,s) = k and u(s,t ) = - k , we obtain the minimum weighted matching of size k.

You might also like