>> Nikhil Devanur Rangarajan: So welcome everyone. It's my pleasure
to introduce Laszlo Lovasz from the London School of Economics. Laszlo
is a Ph.D. from Budapest and spent a couple years in Georgia Tech doing
a post-doc. He's going to talk about a beautiful algorithm for
finding, for generalization of the flow problem.
>> Laszlo Lovasz: Thank you very much and thanks for coming. I enjoy
being here. So to leave some time for those arriving later, let me
just go through slowly through the definition of strongly polynomial
algorithms.
So it's a computational model and our input is given by a number of
numbers. So let's say we have a bound C on the maximum integer in this
input and there are N of them. And like weakly polynomial is just the
standard notion of a polynomial algorithm. It's polynomial in the size
of the input, which is NN log C. But in the strongly polynomial, we
require that the running time only depends on the number of the
numbers.
Of course, things could go weird if we don't have any connection with
the size of the numbers. So we have this bound on the number of
elementary arithmetic operations and comparisons, that's the only thing
which is allowed in this algorithm.
And they require that the numbers during the computation won't blow up
very much. So they stay polynomial in the size of the input.
But maybe that's one view of strongly polynomial. The other is that
it's a computational model with real numbers. You can have arbitrary
even irrational numbers in the input. You don't care how they are
represented whatever. You just assume that you can carry out every
arithmetic operation. So these are two different ways of looking at
strongly polynomial algorithms.
So what I have here is the very basic network flow model. Kind of a
variant of it. So I have a directed graph. I have lower and upper
capacities on the arcs. And that is not completely standard thing. I
have a node demand. BI, which is the requirement of the incoming flow
minus the outgoing flow in every node I and they should sum up to zero
to get a feasible solution. So the minimum cost flow problem is I have
a cost function on the edges, on the arcs and I want to find a minimum
cost flow with respect to the [inaudible] well-known problem for all of
us.
So the first weakly polynomial algorithm for this is given by Edmonds
Karp '72. So it's not like the maximum flow problem which is the
focus, but it came only like two decades later.
So but it has been actually open for a very long time to get a strongly
polynomial algorithm, given by Tardos in '85. So there's a call back
[inaudible] algorithm, if you know one algorithm for minimum cost
flows, that's most likely the one you know. This is this minimum in
cycle cancellation algorithm, if you heard about that.
And there is one by Orlin which will play an important role in this
talk.
Okay. So the problem I'm considering here I have the same polyhedron.
So over the same set of feasible solutions, I want to minimize the sum
of some function value. So I have a convex function on each of the
arcs. This Cij. And I take the feasible flows of these functions with
values on the arcs and I want to minimize this sum. So this is a
convex program, which we can, of course, solve.
It has like all kinds of applications. Let me just show you one. This
is again a picture which everyone has probably seen many, many times.
So this routing problem in traffic networks then you have this city
where on every road transition time is a function of the amount of
traffic, and then we are interested in finding a Nash equilibrium in a
sense that the payers are infinitessimal smaller parts of the traffic
behaves selfishly and they want to pick a path which is shortest for
possible for them if no one else changes. And this is this famous
paradox that in this network we will get this inefficient path. So the
relation here is that computing -- actually a Nash algorithm and
optimal solution in such networks is like falls into this class you
want to minimize separable convex cost function on such network.
Okay. So there are really these kinds of problems we have to think of.
And here is the general formulation of the question I'm investigating
today is there a strongly polynomial algorithm for this convex program.
So it's just this flow feasibility with this minimum convex cost.
>>: How is convex ->> Laszlo Lovasz: That's a very very good question. So the strongly
polynomial it is not precisely defined because exactly of this
question. So okay so the easiest way to look at it is it's given by
Oracle. So you can evaluate this function with a query or what we need
is derivatives and then it's strongly polynomial in the number of
queries and arithmetic operations.
However, it's not terribly interesting. The question from this
complexity point of view, because the answer is a big no for an
arbitrary formulation of strongly polynomial, because even if you
have -- okay. So the first issue is that the optimal solution can be
irrational or even nonalgebraic. So again how would strongly
polynomial algorithm return such a solution. Okay. So then one might
want to relax that maybe that's not the right question.
Maybe they want to find an epsilon approximate solution such that the
running time can be dependent on the logarithm of 1 over epsilon which
is kind of the natural quantity which we might hope for. But even if
these cost functions are polynomials of degree at least three, even
then there is an impossibility result for this, and it's a result
without any complexity assumptions.
So it goes back to original [inaudible] by Renegar which says that it's
impossible to epsilon approximate roots of polynomials and strongly
polynomial time. So if you have a polynomial and interval, you want to
find an epsilon approximate root and unconditionally it cannot be done
with time independent of the length of the interval.
So this is kind of hopeless. So that's the end of my talk.
no strongly polynomial algorithm for this problem.
There is
However, well, so then just some footnotes to this. So this general
impossibility result doesn't apply for quadratic objectives. So then
on every edge we just have some Cij square plus DijX. Okay. So, first
of all, of course for linear costs we do have the strongly polynomial
algorithms. Even for quadratic cost there were certain special cases
studied and proved in the '90s, if you have serious parallel graphs it
was done and also if you have like a transportation problem with a
fixed number of sources then it's also doable.
But the general quadratic cost was still open. And there is another
instance which might look strange at this point. It's this Fisher's
market with utilities. I'll come back to that later because you either
probably don't know what a Fisher market is or you don't understand
what it has to do with it or you've heard some version of the talk and
you know that.
Okay. So what we prove here is a strongly polynomial algorithm under
certain assumptions. And the most important assumption is that if
someone tells us the support of the optimal solution we can exactly
compute this optimal solution, and we come back to that in a bit more
details. And there's some assumptions as well. But special cases will
include arbitrary separable convex objectives -- quadratic objectives.
So without any restructure under the graph we'll include the Fisher
market with a linear utilities already have the algorithm for but also
for this more general class of spending constraint utilities, which was
not known before. So this is -- but more approach will be an algorithm
for the general problem.
We will have some assumptions and certain oracles and such that if we
assume that these oracles can be implemented in strongly polynomial
time then our algorithm can work in strongly polynomial time.
>>: So if we go back -- let's go back to the standard flow problem. So
what does this assumption say -- is the assumption can be implemented
easier than let's say ->> Laszlo Lovasz: Yeah, then it's just like a system of solving linear
equations. So like if I tell you -- like let's say you have low
capacity 0, upper capacity unconstraint on every edge and I tell you
which edge carry positive flow, then you can compute and this must be
tied in the dual. So you can compute the dual optimal solution.
>>: So what is the optimization problem then?
>> Laszlo Lovasz:
Huh?
>>: Is it equivalent to something else?
With the support?
>> Laszlo Lovasz: So for linear cost it's really just solving -- well,
okay, what is it for ->>: Arbitrary [inaudible] solving?
>> Laszlo Lovasz: It's not. Okay. So it's really a very simple one.
You have to solve a system of linear equations in a tree, actually. So
that's what you have for linear cost. So that then you have the
components of the positive edges and you have the demands at the nodes
and you can just uniquely set all -- so it's like ->>: It's easy.
>> Laszlo Lovasz: It's real easy, yes. Even for quadratic, it will be
a slightly more complicated, but I'll -- but that will also be a
special system of linear equation. Okay. So let's just quickly talk
about this Fisher market. We are in a market suggestion where there is
a set of buyers and a set of goods. And every buyer withstood this
market with a budget I which is willing to spend on these goods and
there is one divisible unit from each of the goods. We can always risk
it because it's divisible.
And if buyer I would buy the entire unit of utility J he would get a
utility UIJ and the linearity of the model means if he just buys a
fraction of the goods, then his utility proposition of UIJ. Then
market clearing, market equilibrium, it's a setting of prices and
allocations of the goods which makes everyone really happy and content.
So first of all, the sellers will be certainly happy because they can
sell all the goods even better for them all the money of all the buyers
will be entirely spent. So they really just go home with empty
pockets. But they still think that they made clever decisions because
they only buy best bank per buck products, which mean that those which
maximize the utility per price ratio.
So let's just go through the simple example. There is the beer which
comes with five units of utility for three bucks. But Homer is clever
to go for the donuts which give a better ratio for him.
So this is one of the first equilibrium market, equilibrium problems
ever investigated by Fisher in the 19th century, and it's a special
case of this much more general Arrow-Debreu market equilibrium
theorem -- theory. But it's kind of a very special and very
interesting case. So, first of all, it turns out that this problem
always has a rational optimal solution.
Moreover, we're actually able to compute this rational optimal
solution. It can be formulated as a convex program, which I will
mention later. But there was even an combinatorial polynomial time
algorithm by Nicki Papadimitriou Saberi and Vazirani in 2002, which
like initiated a long study of this kind of market equilibrium problems
in the computer science community.
And then there was this strongly polynomial algorithm given by Orlin in
2010. And it was later extended to several other settings. I just had
to mention one rather than talk today. It's the spending constraint
utilities. The utility of every buyer is a piecewise concave function
of the money he's spending on these goods which is not the most natural
setting. The reason for investigating this is really that we are
actually able to solve it.
But this combinatorial algorithms did extend here but there was no
strongly polynomial algorithm known. Okay. So here is a convex
programming formulation. It looks a bit odd, and I cannot really give
you an intuition in two words why it captures the optimal solutions
capture market equilibrium. So we have a variable YIJ for every pair
of buyers and goods, such that the sum of the variables for YIJ for
every fixed I gives its budget. The sum of the variables summed over
the buyers give the price of the good. So it really shows how the
money flows spending all budgets of the buyers paying the full price
for the goods.
And the objective is something odd. It's there is this linear term for
Dij players. It's multiplied by the logarithm of Cij and PJ minus 1
for the prices, whatever it is.
So actually there is a classical formulation of the problem I didn't
put here by Eisenberg and [indiscernible] from '59 and that's kind of a
more intuitive one, and that's what people have always been using until
very recently and Shymrev and independently and co-authors found this
kind of unexpected formulation.
And okay. So my main, well, contribution to this market equilibrium
area in this talk is this one line obvious observation that this model
is actually a flow with a separable convex objective. So it's
something really straightforward. I just show you the picture. There
are these goods and the buyers and I add one additional node, which is
the, it's connected to all the goods. These numbers are the node
demands. So it has a total demand of minus some of the budgets. So
which means we are sending money out here. We don't keep anything
here. And for the buyers, the incoming must be the budget. And then
we have this PJ times log PJ minus one functions on the edges
connecting the source and the goods, which even if ugly it's a convex
function. And we have these linear functions between these edges.
So we can treat this problem in the general framework of this convex
cost flows, and even the spending constraint utility formulation can be
easily seen in this formulation.
Okay. So so much about markets. Let's get back to the general
problem. So actually I will -- don't worry, I won't talk about all
four parts. But just the right-hand side. But for linear cost, what
the real starting point -- actually, I have this pointer -- is the
Edmonds Karp algorithm from '72. And then this Orlin result is a
strongly polynomial version of this Edmonds Karp algorithm.
On the other hand, if we move from linear cost to non-linear cost, and
this Edmonds Karp's algorithm was extended by Minoux in '86 what we're
doing is kind of the analog of what Orlin did with the Edmonds Karp
algorithm, we do the same kind of algorithm to this Minoux algorithm;
however, there are many difficulties we encounter on this space.
So let me start with this Minoux algorithm. So first of all let's talk
about optimality. To start with, it's a very standard transformation
always in flow problems that we can just assume that in every art the
lower capacity zero and the upper is infinity. So there is this simple
transformation you can convince yourself that if you have an edge with
lower upper capacities, you can replace it by two oppositely directed
edges going into a new node and then you can simulate these capacities
with the node demand constraint there.
So what we are looking at is not the original graph but the residual
graph given a feasible solution or an unfeasible solution. We have all
the edges as forward edges because they have infinite capacity and we
have the reverse edges of every positive edge in this residual graph.
And then if you look at the KK conditions, then you can figure out that
solution, feasible solution is optimal if and only if the residual
graph doesn't contain any negative cycles with respect to this cost
function, which is the derivative, which is the final oppositely on the
reverse edges.
Well, if there is a negative cycle, then you can kind of send a small
amount of flow around it decreasing the cost and the KK conditions also
show the converse. And, okay, so the way we can look at it
equivalently is this potentials on the nodes which actually correspond
to the log range multipliers and optimal solution so that the potential
difference on every arc of the residual graph is at most derivative.
Which means that on every positive arc we must have equality here.
Okay. So there is this scaling technique which was introduced by this
Edmonds Karp paper. So it's a very, very simple but super efficient
idea.
So what it is about is only that first we just want to go for the huge
parts in the problem and then refine it later gradually. So let me
illustrate how this algorithm goes. So we have to clear up a
construction site. So first comes this big excavator machine, which
takes care of the huge parts. And then comes this smaller electric
shovel or whatever it is. Then we go down to this smaller manual
shovel. And then the broom and finally for the very fine parts we go
for the brush. So this is what we're really doing in a scaling
algorithm.
So to put this picture into a mathematical form, we have a scaling
factor that in every phase of the algorithm, which keeps decreasing by
a factor of two, between two phases. It plays a double role in the
algorithm. So in the Edmonds Karp algorithm, its only role is flow is
transported in these units of delta.
So in a delta phase we will send flows with huge excess to very
negative nodes in units of delta. But the other, and this is the new
contribution of Minoux, is that the optimality is also relaxed to that
accuracy. And as that goes to zero, then the extra solution will
become more and more feasible. I will come to that. And at the same
time it will become more and more optimal.
So what do these things mean? So, first of all, let me remind you that
the optimality condition would be that the residual graph contains no
negative cost cycles with respect to the derivative. Relaxed by adding
here delta. So the derivative in Fij plus delta. Because the
functions are convex, the derivatives are increasing. So this really
is a relaxation. And as delta goes to zero, it goes to the optimality
condition.
On the other hand, so what I want to emphasize that the flows during
the algorithm are not feasible. There are positive and negative nodes.
The delta positive node is where the flow balance like incoming flow
minus outgoing flow exceeds this demand BI by at least delta and the
delta negative node is where we need at least delta more flow to
balance it.
Okay. So now this algorithm is very simple. Start with all flow
values set to 0 and a very huge delta value which is like the maximum
of these node demands. While there's a delta positive and a delta
negative node, then we send delta units of flows between them on a
shortest residual path with respect to this cost function relaxed cost
function. Okay. So we do it as long as there are both delta positive
and delta negative nodes and they are connected by path in the residual
graph. If it's not possible anymore, then this phase is finished. But
now we want to move to the delta over two phase. So we want to
decrease our scaling factor by that and here we do need to have some
additional work. So I have this special subroutine which makes my
actual solution which was feasible for the delta phase one that is
feasible for the delta over two phase. I thought I have it here.
Okay. It will hopefully come on the next slide. Okay. So there was
the same variant in the first place that this relaxed cost function
doesn't contain any negative cycle. So the first main observation,
which is a very obvious one that if we augment on shortest path then we
cannot create any new negative cycles, that's one property we are using
here. So this invariant is maintained during all these flow mentation
steps.
So now we want to move from delta feasibility to delta over 2
feasibility. So in these dual terms, I claim that on every arc I can
change the flow value by adding or subtracting delta over 2 such that I
get the new, the invariant again for delta over 2.
So let me just argue a bit about this. So let's say I have an arc Fij
which is greater than delta. Then this delta feasibility essentially
means that I have this pi J minus pi I and it has to be sandwiched
between the delta Fij minus delta. And I claim I actually can
guarantee this delta feasibility over the very same dual or Lagrange
multipliers pi IM and pi J, but this is what I can need. But this can
be violated.
Then, for example, this pi J minus pi I is greater than this left-hand
side, then it's easy to see that if I decrease the flow further by
delta over 2, then I can get this condition back and also in the other
direction.
So it's really a simple exercise in convexity to check whichever
direction my inequality is weighed I can move delta over 2 there such
that I get feasibility back.
Of course doing this I make my nodes more imbalanced. But that's
somehow bounded amount right on every edgy create at most delta over 2
new imbalance which I will have to take care in the next round.
So I have this animation here. This is just the exact same algorithm.
So apologies if it's a bit too dense because there are like four types
of numbers with different colors. So this is really the simplest
example I could come up with. So have this network, these two nodes
connected to two others. These numbers inside. They are the demands
or the excesses.
Now, this is the flow value. We start with zero. And these yellow
numbers are these relaxed cost functions. So we start with delta
equals 1 and then actually the derivative. So the function is X square
on every arc and the derivative here is 2 times the flow value times
twice delta. So it's 2 everywhere. Okay. These other numbers are
just the node potentials which are like correspond to shortest path
distances here just ignore them they are not that important.
Okay. So first in the delta equals 1 phase I take a node with excess 1
connected to a node with efficiency 1 and send one unit there,
brilliant. I got rid of one unit of excess and I created this arc
which is a residual arc backwards and this has cost zero so on the
forward arc I have four and the backward arc has zero. I do the same
on the other side.
And now it seems like I have a perfectly feasible solution. I got rid
of all the excess demands. So that's very good. However, we are not
done yet, because we don't have the optimality conditions. So let's
move on to the delta over 2 phase. Now, these numbers -- let's look,
focus on this line. All these numbers changed because I changed delta
from 1 to half. And now I actually created a negative cycle. So -well, okay. It's actually not that negative. It's just zero. But
okay still if I look at the potential differences, then on these edges
I will need 2 minus 0 is greater than 1, and that's smaller than 1 and
that's not really the case. So I have to push half unit of flow back
on these edges. And that's what I do.
So now I created this new deficiencies and accesses. And then what
happens in the next phase, I transport these half units and, well, that
actually happens to be a feasible flow. And that's the optimal
solution that I have half on every edge. Okay. So you might ask how
does it terminate? One way to look at it is based on the input data we
can define small granularity when it's easy to transform it to optimal
solution. But the more convenient way to think about it is that it's
simply never terminates, we run it forever and when it's close enough
for our purposes, then we just finish it.
Okay. So this much about the Minoux algorithm. This will be the base
of my algorithm today. So the first philosophical question is that if
I have a scaling algorithm, how on earth would I make it strongly
polynomial? So I start with a large value of delta, which is like this
maximum demand, and always decrease it by a factor of 2. And I have to
bring it less than 1 or even smaller if necessary. So to get a
strongly polynomial bound, we cannot afford just halving, halving,
which sometimes make, have to do something radical. We have to jump
with our delta, which somehow implies that we need some invariant,
which is independent of delta.
And so
linear
Minoux
really
such a very nice idea was given by Orlin for the algorithm with
cost. That's more or less the same as what I told you for the
algorithm, except the costs are linear and therefore you don't
need these edges. That's really a simpler version of this.
So what he observed in the scaling algorithm is that, okay, let's leave
it run forever. And actually in the norm, so we are converging to an
optimal solution. And in the delta phase we are at most 2 and times
delta far on every edge from this optimal solution. So why is that?
That I didn't make it precise, but in the delta phase, you can do at
most like 2 N flow mentation steps. Every step changes flow by delta.
So even if on an edge every such path traverses it and everything is
adversarial, even then you can at most get -- well in the delta over 2
phase you can get 2 N times delta over 2 delta over 4 N sums up to at
most 2 N delta. So what we may conclude is this very simple
observation. If we find an arc, which already has flow strictly larger
than this 2 N delta then this arc must be positive certainly and this
optimal solution. So how do we want to use this information?
So then we actually realize that it's not the prime problem we really
want to solve but the dual problem. If we have a dual optimal
solution, then we can simply compute the primal optimal by flow
computation.
So and by the slackness, this arc must be tight in every dual optimal
solution. So what we can do -- we have to change our objective, and
then one thing which follows from the analysis of the algorithm is that
if it starts running the standard scarp algorithm in order log N phases
we will find such an edge which is huge.
And then what we do, we just simply contract it. Forget everything and
restart the algorithm. Now, we have a smaller problem. Let's say we
have an optimal dual solution on the smaller problem, then we can just
obtain a dual optimal solution in the original graph, using that this
edge must have been tight. So it's really sufficient to solve the
problem on the smaller graph and then again in order log N phases we
get new edge which we might conclude that it must be tied in an optimal
solution here we can contract it and so on.
So we just keep reducing the size of our graph. And that's it.
Actually, this is a very simple idea. But it's not the most efficient
thing always to throw out everything we have done and restart from
scratch. Actually, Edmond Orlin has a super efficient version of this
working directly on the original graph that's for the last 20 years
that's like the most efficient algorithm for minimum cost flow. So
this truly is an efficient technique.
Okay. So let us now move to our setting finally where we have the
non-linear cost on the edges. So just for this talk, let's assume that
all of them are strictly monotone. This is not needed for the result.
But it's easier to explain it this way.
So then, because of the strong -- okay. So actually had it in quite a
few previous talks. So this is strictly convex. Sorry. So if I have
strictly convex objectives, then I have unique optimal solution. And
then let's take the support of this optimal solution, the positive
edges. And then here comes my first key sub routine assumption. If
someone tells me this optimal set of edges, then they have the sub
routine trial F star which can compute exactly the optimal solution
strongly polynomial time. So let's check this one for the quadratic
cost. So I have this cost function on every edge. Then if I look at
the optimal KK conditions, then I have this system of linear equation.
So this is just that outside F star I have to be zero. I have to get a
feasible flow F star. And I also have these pies on the nodes that the
potential difference on every arc in this F star equals the derivative,
which is this linear function in F star.
It's not entirely trivial to solve it, but fairly simple. And it
always has a solution if and only if on every component undirected
component of F star these BI values sum up to 0. Then it has a unique
F star solution.
Okay. So we will want to use this oracle. However, not only for the
final step, but even sometimes before. So that's the main idea would
be is that we are very keen on finding out which is the optimal
support. And what we will keep doing is that we always maintain a
candidate set for this.
So we start in the first step we don't know anything. Our candidate
set is zero is the empty set. And we always only add new arcs to it if
we are really sure that it must be in this optimal support. And we
will be able to extend it in every order of log N times.
So, first of all, let's look at how we can use Orlin's trick. If we
have an arc, which has very large amount of flow, then same argument
works. We have slightly verse constants because the algorithm has some
extra steps but we can do that.
So if we start the same argument shows that we have -- we soon have to
find such an edge. However, we cannot contract it. So why can't we
contract it? Well, in Orlin's agreement we had separate primal and
separate dual solution, and we could just change our focus to the dual
solution.
But now here we have constraints which contain both this pi values and
the solution values. So we cannot just reduce our problem to a smaller
one. Also, an indication for that is that we have seen on the tiny
example the optimal support might be sometimes it must contain cycles.
So for sure we cannot contract because then we would kill the
possibility of cycles.
Okay. So if we don't contract, what do we do? We keep doing a
variation of the algorithm and somehow guarantee that we extend this
set of arcs in every log N phases and since it cannot -- in the worst
case it solves edges it gives total bound N times log N on the number
of phases.
Okay. So the question is how do we jump in the algorithm? So we keep
running the same Edmonds Karp algorithm, and whenever our set F -- so
in the first place we extend our set F if it has an arc with a large
flow value. And then whenever we do make progress, we have extended
it. And we make an optimistic guess. Maybe we've already done that.
Who knows. But let's check it.
So then we use the sub routine trial, apply it for actual set. And
this will find us a solution to some system which is the same as we
have seen on the previous slide with FE instead of F star. So it gives
us a flow which satisfies optimality conditions here.
But that doesn't mean that it's an optimal solution. For example, we
cannot out true that it has some negative edges. Still, what we do, we
have another sub routine. This error sub routine. I will talk about
it later, which tells us what is the minimal delta prime such that if
we look at this solution X, then it would satisfy all the necessary
conditions which we would jig fire in the delta prime phase. We don't
want to write the conditions, they're a bit technical, but they're
natural, but I don't want to go into this detail.
So again the idea of we make the optimistic guess. It returns a sum
solution, and then for that solution we find out that which phase would
it be suitable for.
Well, there's three options. This is 0, which clearly shows that we
are already done. We get an optimal solution. If it's smaller than
delta prime, this is when really the jumping happens. And we forgot
whatever we had so far in terms of F. We move on to this new solution
X returned by oracle, and replace that over 2 by this new delta prime,
which can be like way much smaller.
And then there is a cert scenario. It's not only that we don't know
that it's smaller than delta over two. It can be even larger than
delta. So we can possibly arrive at the solution, which is worse than
our current solution.
In this case, we just don't do anything and move to the delta over 2
phase as if nothing happened. So it was an unsuccessful trial. And
kind of the surprising thing is that even -- even if this scenario
happens, although we didn't make an actual progress, we have some
information which guarantees that within a small number of steps, we
will be able to extend this. We'll be able to extend or support F.
So this is based on this following key lemma is that this delta prime
cannot -- it can be worse than our actual delta but it cannot be much
worse. So we cannot terribly destroy or we are not very far from the
actual situation, even if we make this guess.
So if we have this lemma, then it's easy to see that we must extend our
solution soon. So first case let's say that we actually couldn't make
any progress. So we move down to the delta over 2 phase.
Since in every phase we decrease our scaling factor by at least a
factor of 2, then in log N phases, we get a scaling factor, which is,
well, much smaller such that the 4 times M squared times delta double M
prime is smaller than our QM delta prime.
And the important observation is that the subroutine we are using, it
only depends on the set of edges in F. So if we run it again, if we
still have the same F, then the subroutine will return us the same X
and then we get the same delta prime, and then the conclusion is that
the delta prime is at most this 4M square times the new delta, which is
the delta double prime, which is smaller than delta prime as we heard.
So it really testifies that F must have been extended in the meantime.
And the other case is it's just the same if we moved, instead of delta
over 2 to the delta prime phase, then again in log M phases we will or
new value will be 4M squared times smaller than the actual value. So
the very same algorithm works in both cases.
And that's pretty much it. So the basic idea once more is very simple
apart from some technicalities, we maintain this candidate set of
optimal support. We pretend that it really is the optimal support and
this either gives us much better quality solution or it gives us a
guarantee that we must extend our set soon.
So let's just talk a bit about these sub routines. So this trial F
satisfies this solution satisfying the optimality conditions in both
our applications for quadratic objectives, Fisher markets is just
solving a system of linear equation, and it's a special system which we
are actually able to solve. And then this error sub routine. It needs
to find a smallest delta such that X is feasible in the delta phase,
which I didn't precisely tell you what it is. But the way you have
to -- okay. So for quadratic objectives, it goes back to a very nice
problem. This is this minimum cost to time ratio cycle problem, which
means that on every edge you have a cost and you have a time, which is
a positive number. You want to find a cycle which minimizes the cost
per time ratio. So like if the time is one unit for every edge, then
this is like a minimum mean cycle, but we can do it arbitrarily by
assigning different weights to the edges and there is this really nice
result by [indiscernible] nontrivial one that you can solve this one in
strongly polynomial time.
For Fisher markets, it's actually simpler. It's an all pass shortest
path computation. So in terms of running times for quadratic
objectives, it's like an M squared -- M to the fourth times log N. So
that could be better. But I mean, it's not terribly bad. And for this
Fisher markets with spending constraint utilities we also get this M
cubed log M type algorithm where M is the number of like this price
segments altogether, which I guess is compared to most of these market
algorithms that is a quite reasonable one.
Okay. So let me just finish with some questions. So the first natural
way to proceed would be to, instead of the flow polyhedron, let's take
a arbitrary polyhedron with the bound on the maximum subterminal
constraint matrix. Like flow polyhedron it's minus 1-0 or plus 1,
geometrics. But more general, you can look at this bounded case and
actually for linear cost functions there is this result by Tardos, the
flow result which gives us strongly polynomial algorithm for all these
kinds of problems.
And even more encouraging for this very same problem that separable
convex cost on such matrices with maximum subdeterminants we have
combinatorial but weakly polynomial algorithm. So if we could extend
this, that would somehow have the message that like separable convex
costs are just equally hard as, not harder than linear cost. Actually,
like the title of this Hockbaum Shantikumar paper is pretty much this
that quadratic programming is not much harder than linear programming,
but it would finally really verify this.
If it could extend this result for quadratic costs there. And one more
quick remark. So for this strongly polynomiality, of course the really
big question around is for a general linear program you can find a
strongly polynomial algorithm, which it's a very persistent question.
But probably a good and not completely hopeless sub problem is that
generalized flow problem. So that's just a flow feasibility problem,
and you have a multiplier on every edge such that the outgoing flow is
a multiple of the incoming flow by this factor. So actually that
doesn't fall into this class, but it still has a very simple matrix.
You just have two non-zero entries in every column, but they can be
like arbitrary numbers without any integrality restriction. So that's
actually a problem I'm working on a lot nowadays.
So thank you for your attention.
[applause]
>> Nikhil Devanur Rangarajan: Any questions?
>>: I have a question. With the constraint performance [inaudible] so
this Orlin's algorithm, it's different from --
>> Laszlo Lovasz:
Yes, it's --
>>: So those techniques work for this generalization for ->> Laszlo Lovasz: Yes. Yes and no. So yes so there are actually two
very different paradigms for minimum cost flow problems. So one is the
scaling type of algorithm and that's what Orlin makes strongly
polynomial. But the other is -- so here what you have, you maintain
the optimality conditions all the time. But the feasibility is
violated. You can have access and demand in the nodes. And then the
other approach is that you maintain feasibility, but you can have
negative cycles. So optimality is violated but obviously [inaudible]
is maintained and you progress by canceling cycles. And then so the
Tardos is like the cycle canceling paradigm. Like for these two
algorithms, it's also the Hockbaum Shantikumar in some sense it's this
feasibility scaling and this other one is the Tardos canceling type
algorithm. And I was actually -- yeah, that was like the first thing I
wanted to do to make cycle canceling strongly polynomial in the
setting. But I just simply couldn't. So that's -- they're very much
more serious issues which I don't even remember all that.
>>: And for the probability -- you can't use the Tardos and don't make
it ->> Laszlo Lovasz: Yeah, that's what I'm saying, that's what I first
tried and I couldn't do it.
>>: So what I asked is can you do the Orlin's type for this ->> Laszlo Lovasz:
should be doable.
Yeah, that's the question.
But it's like --
I mean, I think it
>>: [inaudible].
>> Laszlo Lovasz:
Hmm?
>>: Even for linear cost functions?
>> Laszlo Lovasz:
For linear cost functions, yeah -- that's actually.
>>: [inaudible].
>> Laszlo Lovasz: Okay. That one I didn't look at.
been done actually. I'm not sure.
But it might have
>>: That could be useful.
>> Laszlo Lovasz: Yes. So that might access such a result.
went into this direction. Yeah.
I never
>> Nikhil Devanur Rangarajan: Let's thank him again. [applause].