>> Mohit Singh: Hi everyone. We are pleased to have Vahid Liaghat speaking today. He has been in
town this summer and will be finishing next week and today he will speak about some online nodeweighted Steiner network design problems.
>> Vahid Liaghat: Thanks everyone for coming. I hope that you can hear me. So it’s a joint work with
Debmalya and my advisor Mohammad. And this is about online node-weighted Steiner connectivity. So
let’s just go to the basic definitions if we can. Okay. So okay, let’s see what’s an online problem? An
online problem the requests are coming online and when you get the request you have to make an
irrevocable decision to somehow serve the request. But this decision should be made without knowing
the future requests. Okay?
And how do we measure the performance? We say that okay we compare our [indiscernible] of the
algorithm compared to the optimum which knows all the requests in advance. So that’s why we call it
offline optimum. [indiscernible] is simply the worst case ratio our cost or offline optimum
[indiscernible] sequences. Okay?
So what is node-weighted Steiner forest? We have a graph with node-weights wand then there is a
sequence of pair of vertices si and ti. And the goal is to find the minimum cost subgraph which connects
every pair. Okay?
We can also imagine edge weights but node-weights are more general. We can simply put a vertex on
every edge with the weight equal to the weight of that edge. Okay?
We also assume that these si, ti’s and they don’t have any weight or their weight is just zero. This
[indiscernible] only simplifies the explanation. Okay?
So this is the node-weighted Steiner forest. For example if we only have one demand s1, t1 then this
would be the optimum solution. If we have s2 and t2 as well, this would the optimum solution which
can be disconnected. That’s kind of why we call this Steiner forest. And then if we have s3 and t3 some
demands may actually benefit by sharing and then the optimum solution would change to this. Okay?
So what’s the online advantage of the problem? We know the graph in advance is very important. But
the sequence of demands are coming online so after we give a [indiscernible] si, ti we need to augment
our solution to actually keep si and ti connected. But we can only buy new vertices. We cannot you
know give back the vertices that we have already purchased. Okay? That’s why it’s kind of irrevocable.
Right? And we want to be competitive against the offline optimum. Okay?
So let’s see some bad news about these problems. So a Steiner forest is a special case in which, Steiner
forest to a Steiner tree in which all the demands share a common vertex, which basically means that we
only have a set of terminals and they interconnect every way to each other. Okay?
A special case of node-weighted Steiner tree is a set cover problem where we have a universe of
elements and even a collection of subsets of these vertices. You need to choose the minimum number
of sets such that every element is covered at least once. Okay? And you can see why this is a special
case essentially for every element you put a terminal those vertices which you want to connect and for
every set we also put a vertex and connect every set to the elements which are covered by that set. And
then we put a special terminal here and we ask all the terminals to be connected. So essentially
connecting a terminal to the root here means buying one of these sets. Right?
Also note that set cover is only a special case of node-weighted Steiner tree because if you have only
edge weights, for example, if you move the weight of these vertices to the edges, actually this won’t be,
it won’t be a special case. Because the cost of the set cover is two but now you can actually find, after
you route all these, all the terminals to the root with only paying one. Okay, so it is important that only
node-weighted Steiner trees more general than set cover.
So the bad news is that for the online variant of set cover you roughly can get a lower bound of log2n.
So this means that for all of these problems we have at least a lower bound of log2n in the online
variant. Okay?
So this was the bad news. Let’s see what has been the good news. The first good news is that online set
cover can actually admit almost a tight upper bound of log2n and it is due to [indisicernible]. This whole
framework can also be generalized to many other problems. For example, non-metric facility location
which is … we will get to this problem later.
And then in 2011 Naor, Debmalya and Mohit , they actually developed the first competitive
[indiscernible] competitive algorithm for a Steiner tree, node-weighted Steiner tree by giving a log2n
competitive algorithm. Although there’s no known generalization of the online [inaudible] Steiner forest
and they left the Steiner forest problem as an open problem. Okay?
So what we are going to do is start, we are going to give a [indiscernible] competitive algorithm for
node-weighted Steiner forest online variant. And then we are going to give a better competitive
algorithm, actually a [indiscernible] competitive algorithm when the underlying graph is planar, or in
general it excludes some fixed edge as a minor. And then we can show that always the same guarantees
both for planar and general case carries over when a problem seems more general than a Steiner forest
when the cut constraints are kind of characterized by some proper function, which I probably will skip in
this talk. So we essentially try to design a kind of framework of working with node-weighted online
problems to deal with these two. So …
>>: [inaudible]
>> Vahid Liaghat: No, it should be a 0, 1 proper function. Yeah, yeah [indiscernible] proper of 0, 1.
>>: [inaudible]
>> Vahid Liaghat: Not yet actually.
>>: [inaudible]
>> Vahid Liaghat: [inaudible]
>>: [inaudible]
>> Vahid Liaghat: Yeah. So I will quickly go over our approach in a few slides and then I will formulize
everything from scratch. So first let’s try to give a lower bound for the optimum solution. Let’s say that
these black vertices are the terminals and you want to connect them somehow. Let’s see how we can
give a lower bound. So of course one way to go is to write an [indiscernible] and then get the dual but
we don’t need to exclusively go to that. We just use the idea as behind the dual kind of [indiscernible
that we have.
So let’s suppose that for now, suppose that the edges only have weights. And suppose that I am
drawing some disks on every terminal, some of the terminals, such that these disks are non-overlapping.
Okay? Then I can claim that the optimum solution is at least the total radii of all these disks. Why?
Because the optimum solution should connect these terminals. So this means that for every terminal
the optimum solution should come from outside the disk and reach to the center, which is this terminal.
So, essentially the optimum solution has to pay at least the radius of this disk. Okay? So the total radii of
all these disks is a lower bound for OPT. And of course I want to make them as big as I can so that I have
better lower bound for OPT. Alright? But I don’t want them to have any intersection, any overlaps.
Okay?
>>: So why do the disks have node-weighted [indiscernible]?
>> Vahid Liaghat: So eventually we will get to the formal [indiscernible]. What it essentially means is
that it starts from the center and just reach to every terminal which is reachable by radius r. And just
[indiscernible] just the intuitive ones. Draw a disk circle exactly.
>>: [inaudible]
>> Vahid Liaghat: Some radius. I mean every disk can’t have a radius. Okay?
Now if you keep growing these disks, at some point, so assume that these are disks, well they’re not
exactly disks but okay. At some point you get into some intersection. And if you grow them a little
more then you will have an overlap. Right? So at this point you see that one natural way to deal with is
to somehow connect these centers, these terminals to each other, by connecting them to this
intersection vertex. Such a tree we call them spiders and in the center of this spider the only vertex
which can have degree of more than two, and these are the legs of the spiders. Okay? You will see a
little more about them.
So this is essentially the whole disks business that we have. Now let’s try to actually design algorithm
for edge-weighted variant. Okay, so we have edge-weighted Steiner forest online values. So what
[indiscernible] that suggests whenever you get this new terminal point of the terminal, s and t, simply
connect, simply buy the shortest path, but the shortest path considering the previous vertices that we
have purchased. Then you get a discount [indiscernible] we get them for free. Now for the shortest
path, let’s say the length is d, and then buy that shortest path. And to try to pay for that shortest path
try to put a disk of radius almost d on either s or t. So we’re just going to give s and t there the shortest
path d. You buy this path and then you will try to buy a disk, [indiscernible] put a disk or s or t. Let’s say
we draw disk d over 4. 4 is just some constant. Okay? If you can do this then you are really happy
right? Because you satisfied the request and you put a disk here so this means that you can charge the
cost of that shortest path to the radius of this disk. But the catch is that there will be some previous
disks here which have intersection with both of [inaudible] s or t. Okay? So essentially you won’t be
able to buy, you won’t be able to put this disk without overlaps.
>>: Okay so the idea is basically that you use the shortest [indiscernible]
>> Vahid Liaghat: Yeah, exactly.
>>: Okay.
>> Vahid Liaghat: Yeah. You can assume that these are only edge weights. Okay so it’s kind of more
[indiscernible].
So we won’t be able to put these disks. Instead we are going to do something else. We are going to
connect s to the corresponding center here and t to the corresponding center here. Okay? So what do I
get now? What I get is that now your s and your t are actually connected in my current solution. Right?
They may not have been connected before. But now I am sure that they are connected. Okay?
So what I’m going to use and somehow I want to use this fact. How I am going to say that okay assume
that the radius of these disks have been also the same. So almost all of these have the same radius d
over 4. Okay? Then I can say that this path that I am, this extra path that I am buying, the length of
them is at most d over 2. So this means that if you have s, you [indiscernible] s and you [indiscernible] t
have been already connected [indiscernible] contradiction. Why? Because I said that the shortest path
between s and t is d. But if these guys have been connected in my solution before, then I can go from s
to here [indiscernible] less than d over 2. Then jump to u, t with the vertices I have already purchased
and then go from u, t to t. But this means that my shortest path is actually less than d. This is a
contradiction. Okay?
So, by actually doing this I can, I’m sure that u, s and u, t have been connected exactly in this instance, in
this step. Right? So this means that if I keep all of these with the same radius together, then every time
that I have such an [indiscernible] that they cannot put a disk, a new disk, I’m reducing the number of
connected components. These two have been disconnected and now they are connected. Okay?
So what I am going to do is that for every power of 2 for every radius of power of 2 I am going to have a
layer such that all the disks in that layer have the radius 2i. And then whenever such a [indiscernible]
happens that I have one [indiscernible] to put a new disk I am reducing the number of connective
components. So this means that I can charge my cost either to the new disk that I am putting or if I am
not putting a new disk I can charge it to the previous disks. But I can only reduce them by the number of
disks that they have. Right?
So that’s one way that we can actually solve the edge-weighted variant, which is due to Berman and
Coulston. Okay? And let’s see one time what goes wrong in the node-weighted variant. In the nodeweighted variant the issue is that [indiscernible] can do the same thing by the shortest path and then try
to put a disk. But now the intersection happens on the vertices so you may get intersection with many
disks at the same time on one single vertex. Okay? So the natural generalization would be to buy these
yellow spiders and then hopefully say that okay I am reducing the number of connected components
and the same [indiscernible]. Right? But this doesn’t happen because this intersection vertex might be
very expensive. It might be the cost of all this spider completely concentrated on this vertex. So this
means that s and t might actually be far from each other because we have not purchased these
intersection vertices before. So we cannot say that these guys are disconnected. They might be actually
already connected. So even if you buy the spiders you may not be reducing the number of connected
components. So this argument fails.
But let’s say if it actually fails, I mean how can we fix it? So for example, if this degree is kind of
constant, this yellow degree, the number of legs of this spider, if it’s constant then we can almost do the
same [inaudible] right? Instead of d over 4 we put d over some bigger constant. So the nice thing is that
if the underlying graph is planar we can argue that the average degree of, the average, let’s say the
number of legs is constant. So somehow we can actually amortize over the whole number of disks. So I
tell you again you still can pay for all the paths that you are buying by charging them to the number of
disks. That’s how we will see that we can it for planar graphs. But for the general graphs, this
completely fails. I mean there is no bound on them. Which really then we cannot just greedily buy
these both as spiders. So we need to be more smarter. Essentially we need to buy some of these
intersection pieces to somehow keep them, keep their connectivity structure on them. Okay?
To do that, we essentially are trying to open the facility on the intersection vertices and then connect
the close disk to essentially this intersection vertex. Right? So this is the whole idea that the relation
between facility location that we will see later, with the idea to you somehow buy these intersection
vertices a little less smarter. Okay?
But then there are some, the catch is that it’s not just the yellow spiders that we are buying. We are
also buying the shortest path. So we need to make sure that this kind of facility location needs to pay at
least this much, d, so that we can charge the cost of our shortest path, also to this facility location.
So this is the whole framework for kind of going to this problem. But let’s formulize everything by
starting from disks. So we formulize them as a kind of painting. We say that every vertex has an area
equal to its length and disk of radius r from the center t essentially means coloring every area which is
reachable by distance r from that center. Okay? Note that we are assuming that [indiscernible] zero so
the centers always have a zero. So more about centers. Okay?
And then just to name some vertices that will be useful we say that the content of the disk contains the
vertices which are, which the distance to the center is less than the radius. Okay? And the, so these
would be the, these are the vertices which are closer to the center than the radius and the
[indiscernible] vertices, which the distance is at least the radius and they are partially colored. They will
be on the boundary of the disk. Okay? So every vertex on the boundary is at least partially colored and
the vertices …
>>: [indiscernible] you say it again so what is boundary exactly?
>> Vahid Liaghat: So the vertices inside are those which the distance to the center is [indiscernible] less
than the radius …
>>: Okay.
>> Vahid Liaghat: Those on the boundary are those which their distance essentially minus their own
weight is less than the radius but the radius cannot exceed their distance.
>>: Oh, okay.
>> Vahid Liaghat: Okay? So it’s just trying to formulize [indiscernible] the disks. I mean less meaning to
go over with radius r. Okay?
>>: And you can assume that the centers are all [indiscernible].
>> Vahid Liaghat: Now this for example, at some point we have [indiscernible] disks on one painting and
we say that these are non- overlapping if you are not over coloring in the vertex. Okay? And then if for
example one vertex goes tight at the intersection of one pair of disks, we are interested in this binding
spider which essentially connects the intersection vertex to the centers of those disks. Okay?
>>: Would you say the disks [indiscernible] the bounding?
>> Vahid Liaghat: Yes. Well this essentially is this coloring, this painting that you put there. Yeah.
Okay?
>>: And what is the usual forward color?
>> Vahid Liaghat: You color one vertex more than its weight. I mean, a vertex kind of has an area equal
to its weight. Right?
>>: [indiscernible]
>> Vahid Liaghat: It’s just, well this is essentially function, right? Function which, and color some
portion of every vertex. Right? So if you put these disks to each other, you would color more of the
vertex if its …
>>: But essentially [indiscernible]
>> Vahid Liaghat: Essentially yes. You can also give a dual inter partition. These are actually dual
objects. But you just don’t want to go to the primal-dual world.
>>: Yeah, yeah I understand.
>> Vahid Liaghat: Yeah. So we call this binding a spider when some vertex at the boundary goes tight.
Okay? So an average of [indiscernible] for example if you have, suppose that all the disks have the same
radius r, for example if you have c disks, then c x r is a lower bound for OPT if they are non-overlapping.
And also for example if you have a binding spider which is at the intersection of for example three disks,
then the cost of this binding spider is 3 x r. That’s from the center of the disk to the intersection vertex
is just r. And everything is tight. Right? In a binding spider?
So these are some things that you can verify by just looking at the [indiscernible] and not the disk. So
let’s go to the algorithm. The simpler one is for planar graphs so let’s go with that one. This is
[indiscernible] H-minor-free graphs. While I am sure that most of you know what a [indiscernible] is but
just to be sure let me say graph G is H-minor-free. If you cannot, however you contract an edge or
remove an edge you won’t be able to reach from G to edge. Okay?
A famous example, famous family is basically the planar graphs. And there are many interesting
properties about H-minor-free graphs when H’s are fixed, the more constant sized graph. The most
important one that we are working with in this paper is that the average degree of H-minor-free graphs
is actually constant. Okay? For example for planar graphs you know that it’s [indiscernible]. Okay?
So I’m just going to explain the exact algorithm for H-minor-free graphs. It’s the same idea that we had
before so we give these new terminals s and t. You find the shortest path between s and t but of course
we’re getting this count from the previous vertices that we have purchased. Let’s say that this
[indiscernible] is d. Then we, first we buy the shortest path so we will satisfy this demand. Then we
choose the layer i which is roughly d over some big enough constant [indiscernible]. Okay? This is just
some big enough constant. Don’t worry about it. So we choose that layer i. We have these layers of
powers of 2 for radius of the disks. So layer i will contain disks of radius 2i. Okay?
Then we buy the shortest path and then we try to put a disk centered either at the s or t. If I can put a
disk there without any overlaps then I’m happy. That’s it. But if both of them are unsuccessful I am
going to buy these binding spiders at the intersection that happens. Since we just see it let’s say that s
and t are the new terminals and the distance is d. Okay? I buy the shortest path. I try to put a disk of
size roughly d over [indiscernible] either on s or t. If I can put it without any overlap then I will just put it
there and I am happy. I will be able to kind of charge my cost to the radius of this disk. But if it’s not
possible for both of them then this means that there are some intersections here. Right? Both here and
here. I’m just going to buy both of these binding spiders. For example here, this is one binding spider
and here’s the second binding spider. Okay? That’s the whole algorithm.
>>: But you might want to intersect at just one place. [indiscernible]
>> Vahid Liaghat: That’s just [indiscernible]
>>: Do you know if the second step is necessary?
>> Vahid Liaghat: Binding spider?
>>: Yeah I mean is it possible with only …
>> Vahid Liaghat: Oh yes. If it’s greedy then [indiscernible]. If you don’t buy this binding spider then
you will just buy shortest path. This mean that you are greedy. And the whole idea is that when you
buy these extra binding spiders you’re kind of giving this challenge to your future self that you will be
able to actually go the shortest path there.
>>: [indiscernible] the edge were not necessary.
>> Vahid Liaghat: Yeah.
>>: I mean you may lose, you lose a little bit in [indiscernible].
>> Vahid Liaghat: Yeah.
>>: [indiscernible]
>> Vahid Liaghat: [indiscernible]
So let’s see how we can analyze this. Again it’s, you want to just charge the cost of all these paths that
we are buying to the radius of the disks. Now I can assume that we only have log n layers. I mean we
kind of scale down and stop so that we can only, we only need to keep log n layers. And then if I can
actually successfully charge the cost of my solution to the radius of the disks, this will give me a log n
competitive algorithm. Then every layer would be a lower bound for OPT and then all we have are log n
layers. Okay?
>>: [indiscernible]
>> Vahid Liaghat: Okay so you buy the shortest path.
>>: Okay.
>> Vahid Liaghat: Now you try to put them [indiscernible] D over [indiscernible] in the layer which is …
>>: Put D over [indiscernible], right?
>> Vahid Liaghat: So we essentially put the layer r [indiscernible]. Okay? So you go to your layer and
you try to put a disk on s. If it doesn’t have any overlap you are done. If there is no overlap you try for t.
>>: Okay.
>> Vahid Liaghat: If it, again if there is an overlap then you just, you just buy this binding spider. That’s
it. You don’t put any disk. Instead you buy these binding spiders.
>>: And what is a binding spider again?
>> Vahid Liaghat: If you cannot put a disk in on here this means that there is intersection with previous
disks.
>>: So what is the center of the spider that you buy?
>> Vahid Liaghat: At the intersection vertex. And the intersection vertex is caused by putting a new disk
with previous disks. Okay. So if you want to buy, essentially put a new disk here, then you will get
intersection with these two previous disks for example at this vertex. You may have different
intersection points.
>>: Which terminals are involved in buying the spider?
>> Vahid Liaghat: The centers of the disks which are touching this intersection vertex.
>>: [indiscernible]
>> Vahid Liaghat: Yes. I will force the new one [indiscernible].
>>: And they intersect, separate sets, no? [indiscernible]
>> Vahid Liaghat: Yeah just one single vertex, one intersection vertex for x and one intersection vertex
for c. So now our total cost is the cost of the shortest path that I’m buying plus the possible binding
spider that I may buy. So if I can, so I have [indiscernible] whether I can successfully put a disk or I
would need to buy binding spiders. And if I can successfully put a disk then I am happy because I am
putting a disk of roughly radius D and I am only paying D so I can charge it. That’s good. Or there may
be binding spiders. There are two cases here. The first case is that one of these spiders is expensive. It
has many legs. By many I mean it has at least [indiscernible] legs. The second case is that both of these
spiders are cheap. They have at most [indiscernible] minus 1 legs. Okay? So I distinguish between
these two different cases.
>>: Just to make sure, what is [indiscernible] so in terms of [indiscernible] what’s the cost of the spider?
>> Vahid Liaghat: The cost of the spider is essentially the number of legs x the radius. That’s an outer
bound because this might be very close to the intersection. Okay? So essentially …
>>: [indiscernible]
>> Vahid Liaghat: Exactly. Then both the spiders are cheap. This means that, I mean this whole spiders
business is just a constant x D. Constant x radius, which radius is D. [indiscernible] is a constant. This is
related to that average degree of my [indiscernible]. Okay?
So that mean s both the spiders are cheap. Then I can use the same argument as the edge-weighted
and say that I am actually reducing the number of connected components. [indiscernible] I am
definitely connecting all of these previous disks to each other. But then they are constant I can claim
that, and these guys have been actually disconnected before. Otherwise there will be a contradiction
with the fact that my shortest path is D. So this can be [indiscernible] if it’s like the edge-weighted
variant. That’s fine. The catch is that I’m actually buying an expensive spider so the way to deal with it
is to show that the total number of legs of all these expensive spiders that I buy in layer i for example, is
at most the number of disks in that layer or that one. If I can show this, then I can say that okay the
total cost that I am paying for expensive spiders is the number of the legs x the radius r. If I can show
that the number of legs is [indiscernible] the number of disks, then I know that I already have essentially
r x the number of disks of the lower bound for OPT, right? So then I can relate it. I can still
[indiscernible] the cost of the legs to the radii of the disks. Okay?
>>: [indiscernible]
>> Vahid Liaghat: No. You need it to be in [indiscernible] so that’s why [indiscernible]. So it’s just proof
of what I teach here. Why we have that. So these are my disks and assume that these are nonoverlapping, well a little hard to draw those. The blue vertices are the centers of the disks in my layer.
The black vertices are the centers of the expensive spiders and the legs are this kind of black, kind of
edges. Okay? And these are the new unsuccessful terminals that they are trying to [indiscernible].
So I know that these are expensive spiders so this is at least [indiscernible] number of legs here. So I am
going to ignore this one extra leg which is coming into s and t. I can double charge it to the other radius.
That’s fine. Now I use the fact that if you have non-overlapping disks this whole intersection, these
intersection vertices are only on the boundaries of these disks. You can’t change that because the
intersection vertex is shared between two disks and the vertex inside the disk cannot be shared with
another disk. Because when you are inside you are fully caught up with that disk. Another disk cannot
have any share in you. Okay?
So these black vertices are actually on the boundaries. So then what you do is you just contract all the
continent of every disk to its center. And then what I have is just a [indiscernible] graph. Between the
centers of the disks blue vertices and the centers are expensive spiders. What I want to do is to show
that the number of legs is in all of the number of blue vertices, because blue vertices are the number of
disks. Legs are, legs are my expensive spiders. That’s all that I want to show.
>>: [indiscernible]
>> Vahid Liaghat: So essentially we have [indiscernible]. Okay if you contract them you will still
[indiscernible] so you have this nice problem [indiscernible].
>>: [indiscernible]
>> Vahid Liaghat: Okay? So the [indiscernible] edge for all the graph. [indiscernible] The black vertices
the minimum degrees [indiscernible]. These are expensive spiders. There is a number of legs that
[indiscernible]. So this means that the blue vertices [indiscernible]. One side of my planar graph is at
least [indiscernible]. Every single one of them. So the average of all the blue vertices is at most
[indiscernible]. So if I buy [indiscernible] graph such that one side is [indiscernible] you see that the
number of edges, the number of legs that most [indiscernible] the number of blue vertices. Okay? The
number of these expensive legs that [indiscernible] blue vertices and that’s why I can essentially charge
the cost of all the expensive edges, expensive legs, to the radius of my disks. Okay?
>>: So the three black nodes are black nodes that are different [indiscernible] for the algorithm?
>> Vahid Liaghat: Yes. At the end of [indiscernible] for every layer we have this kind of picture here, this
[indiscernible] graph. But this is for every layer separately because the radiuses cannot be mixed.
So that was for the planar. Now let’s see what we can do for the general case. Okay? So as I promised
this has something to do with non-metric facility location. Let’s define this problem. In non-metric
facility location problem we have a set of clients and a set of facilities, each with their opening cost. If
you want to open the facility you need to pay this much. And every client, if you want to connect it to a
facility you need to put the weight which is written on that edge. Okay?
And then some of the clients are active which essentially means that you need to connect those clients
to some open facilities. For example if you want to connect all the clients in this problem then the
optimum solution would be this. You need to open facilities here and here and then buy these edges.
Okay?
The nice thing is that the general approach of our [indiscernible] you can give the log2n competitive
algorithm in the online variant of this problem. Okay? So we’ll use this algorithm as a black box. So
let’s see how we want to do this. So, given a network and a radius r I’m going to introduce an r bounded
facility location instance. Just call it r-BFL [indiscernible] follows. So for example let’s say I’m trying to
make a 4-BFL instance. What I do is that for every terminal here I’ll put a client and for every other
vertex I’m going to put a facility. The cost of opening a facility would be simply the cost of that vertex.
Okay?
Now the radius comes in play. The radius is for example r for every terminal I’ll put a disk of radius r on
that terminal and connect the center to the boundaries of the vertex on the boundary of that disk. For
example here the radius is very small. It’s just 4. So the vertex on the boundary of this disk is just 5 and
6 and for this disk it’s just 5. The cost on the edge would be simply the shortest path from that terminal
to that vertex excluding the cost of that vertex. For example here it’s all zero because you know the
radius is very small. For example if you consider 8-BFL instance, again for every terminal you have a
client. For every vertex you have a facility. Now you put a disk of radius 8 or t1. The vertices on the
boundary are 3 and 4. So you will connect t1 to these two and the cost on every edge with the shortest
path of t1 to that vertex excluding its own cost. So for example for this guy the shortest path would be
through the 5. For this guy the shortest path would be through 6. Okay?
So for example I am sure that the cost on these edges is strictly less than 8. Right? Because a vertex on
the boundary, the distance for reaching it should be at most r. Should be [indiscernible] less than r.
Okay? And then for t2 I will do the same. I’ll put a disk of radius 8 or let’s see who’s on the boundary.
There’s 3 and 4 and the shortest path to them is just 5. So this would be my r-BFL instance. Okay?
Clients will be terminals. Vertices will be facilities. And for every terminal I put a disk of radius r and
connect it to the vertex on this boundary. Okay? So that’s just formulizing what we had in the previous
slide. This is my r-BFL instances. Okay? In my algorithm I am going, instead of having log n paintings I
am going to have log n layers of r-BFL, such that for every i I have a 2i BFL instance. Okay?
These are going to help me essentially buy this kind of spiders in some sense. Okay? So my algorithm,
how it’s going to work is that I have this graph and my 2i-BFL instances, whenever I get a new terminal ti
I will buy the shortest path and do some process here. Then if the condition holds I will give this new
terminal to one of my BFL instances. Then I’m going to use the log2n competitive algorithm as a black
box to solve this BFL instance. And whatever that algorithm does in that BFL instance I’m just going to
mimic it in my solution. So if it’s going to open a facility I’m going to buy the corresponding vertex here.
If it’s going to buy one edge I’m going to buy the corresponding path in my solution. Okay? So that’s
how it’s going to work, my algorithm. Okay?
Now I want to say that what is this condition that only sometimes I have a consult with my BFL
instances? The condition is a kind of neighborhood clearance which is kind of symmetric to the fact that
so we are always trying to put a disk, right? If it was not, if there wasn’t any overlap. Here we have the
same kind of situation which we kind of call it neighborhood clearance. It’s some kind of having no
overlap. You see that giving a terminal t to layer i, it has a neighborhood clearance if first there is no
open facility close to this terminal, this client essentially. And this client is at least 2i + 1 far from all the
previous clients which have arrived at that instance. If these two conditions hold then we say that okay,
there is neighborhood clearance for putting term, for giving terminal t to this layer. Okay?
And if this clearance fails this means that there is one open faci, there is either one open facility close to
that client or there is one of the previous clients close to that guy. We call that either open facility or
client, we call it the witness of this failure. Okay?
So should I go over again the neighborhood clearance? So we are trying …
>>: This is for a special case of Steiner trees [indiscernible].
>> Vahid Liaghat: No, no a Steiner forest in general …
>>: But then you have this condition as [indiscernible].
>> Vahid Liaghat: Yes, yes. For now it’s just one terminal trying to go to layer i. If I want to give it to
layer i I should have neighborhood clearance. It is something like saying that there is no overlap
somehow. Okay? Now what is my exact algorithm? So my algorithm is the same, it has completely the
same [indiscernible] we say that you give [indiscernible] demand s and t. Find the shortest path of
length D, buy that shortest path. Now try to give this, give either s or t to the linear i such that, well
layer i such that the radius is roughly D over 4. [indiscernible] very small constant, just D over 4. Okay?
So if there is any, either s or t, either one of them has neighborhood clearance in that layer i I will give, I
will give you that new client that layer and then just mimic the solution of that layer. Otherwise this
means that both of them, essentially none of them have any neighborhood clearance. So we buy the
path from sand t and connect them to the corresponding witnesses. Okay?
>>: What is witnesses?
>> Vahid Liaghat: So the witness, if you don’t have neighborhood clearance this means that something
is near to that, something is close to that vertex, either an open facility or one of the previous clients in
that layer. The witness of failure is that vertex which is too close to that guy. Too close means actually
2i.
>>: [indiscernible] Yeah okay. [indiscernible]
>> Vahid Liaghat: So one of these two is failing right? So this one has, there is already an open facility
there or one of the previous clients in that terminal is too close. Okay?
>>: Okay, sure.
>> Vahid Liaghat: And that close, that thing that is close is the witness of my failure. So if both of them
are failing, I disconnect each one who’s corresponding witness. Of course there might be many
witnesses but just any of them, one of them. Okay?
So that’s my algorithm. So let’s see the, let’s just put some names on these kind of terms here. The first
thing is that for every layer i I will define the optimum solution, offline optimum solution for that BFL
instance as OPT of i. Okay? And the online, essentially mapping for that BFL instance, I will call it m sub
I, essentially the mapping that my online black box algorithm is buying. That is Mi. And then I will say an
iteration is type i if I am giving my clients to layer i. Essentially 4 x 2i is less than D. [indiscernible] here
is just 4. Okay?
Now how I’m going to prove this is by just proving two facts. First I am going to say that OPTi for every
layer is actually a lower bound for the optimum solution to the Steiner forest. This will be easy. It will
be just a proof by picture. Next I am going to say that the total cost of type i iterations are closely
related to the cost of my mapping in every layer. Okay? Now note that if I can prove these two then I
am done. Then I have a log3n competitive algorithm. Why? Because the cost of my type i iterations …
>>: [indiscernible]
>> Vahid Liaghat: So at each time there is a mapping of clients to facilities in every layer. So the online
algorithm for facility location is connecting the clients to some of these facilities. Right? So it’s kind of a
mapping.
>>: [indiscernible]
>> Vahid Liaghat: Yeah, yeah, yeah. So both of them have this sub i so these are about BFL instances.
The offline optimum of the BFL instance and the online solution for that BFL instance. Okay? So if I
prove that the cost of my type i iterations are bounded by cost of Mi then I know that because of that
black box the cost of Mi is at most log2n x OPT i and by this [indiscernible] here I know that this is also
less than log2n x OPT. So the cost of my type i iterations would be at most log2n x OPT and I have at
most log n layers so I would get a log3. Right?
So I just need to prove these two. The first one is easy. Just to show that OPT i is less than OPT. Then
you go over for this one. So first let’s try to show that the optimum solution for every facility location
instance is actually less than the cost of my Steiner forest. So let’s say that these are the clients in my
facility location instance and I have these disks of radius 2i. Of course they may have some overlaps. I
mean if you just put a disk of radius 2i they may not overlap. That was the whole issue. But if you have
an overlap it seems that every time that we get a new client we have neighborhood clearance. This
means that these centers they are at least 2i + 1 far from each other. That was the condition of
neighborhood clearance that the two centers should be far from each other. When they are far from
each other 2i + 1, essentially twice the radius far from each other, the only intersection that can happen
is on the boundaries, which fortunately I have one possible facility for every vertex on the boundaries.
Right?
So just consider the optimum solution for the Steiner forest which is correct in these centers. So it’s
coming from outside every disk and reaches inside, right? So what I am going to do, I am just going to
give a solution for my facility location by just opening a facility wherever this optimum solution is
touching a boundary of one of these disks. I’m just going to open a facility there and then I’m just going
to connect the center of every disk to one of the open facilities on this boundary according to OPT. So
now this would be a valid and feasible solution for my facility location instance. So of course OPT i has
cost less than this, so OPT i is at most OPT. Good? Any questions about this?
So if you just give me any optimum solution for a Steiner forest it is touching every boundary, so just
open a facility on that boundary, on those intersections and then I will just connect the center to one of
the vertices. This will be a valid feasible solution so OPTi is less than OPT. Okay?
So all that remains is to show that cost of type i iterations is at most the cost of the online algorithm for
that facility location instance. Then I am done. Then I have a log3 algorithm. So again my total cost is
the cost of the shortest path and the possible paths to the witnesses plus the cost of simulating the
facility location instance. So by definition the cost of simulation is at most cost of Mi so I am just going
to just buy everything that Mi is buying, so of course it is less than that. Okay?
Now to show that, to show that these two cost some of shortest path plus the path to the witnesses, is
at most 2i. So remember that 2i is essentially the cost of the shortest path, the radius of these disks.
Okay? To show this …
>>: Yes I [indiscernible] colored effort that you put into these slides by matching that, the color coating
is not random at all right? So if the green color is equal to the sum of these two things and the two
things are blue and yellow, so if you add the spectrum of yellow and you get the green [indiscernible].
[laughter]
>> Vahid Liaghat: So, yeah. So I need to prove these two facts to essentially show that the total sum
here is 2i. These two facts are first showing that the number of type i iterations are actually
[indiscernible] the number of clients in their i. So even though some of the time, sometimes I don’t give
a new client it is still fine. So it is still the number of type i iteration is kind of [indiscernible] number of
clients in that layer and then I will show that every time that they give a new client to that layer, my m,
this Mi incurs the cost of at least 2i. If I can show both of these iterations, both of these kind of facts,
then I know that okay, the total cost that I am paying here is some cost sometimes 2i then I get that,
okay so these are in O of the number of clients and for every client Mi incurs the cost of at least 2i, so I
am done.
So let’s see these two facts. Actually the second one is easier, the fact that Mi incurs the cost of at least
2i. Why? Because every time that you get a new client you have a neighborhood clearance, which
means that there is no open facility close to this guy. So if Mi is going to connect this new client it has to
open a new facility and also buy the edge connecting you to that open facility. But this means going
from the center of a disk to one that sits on its boundary and also buying that vertex. So this would be
at least the radius of that disk, which is 2i. So whenever you get a new client in that instance, Mi has to
pay at least 2i. Okay? Because it has to open a new facility and connect it to the terminal.
[indiscernible]
I just want to show that [indiscernible] type i iterations are actually in O of number of clients.
[indiscernible] is just saying that okay, the good thing is that if there is a [indiscernible] it’s in an open
facility or someone close to me. If it’s an open facility, it’s already purchased so if I want to get
connected to it I need to pay less than 2i. But that is not my boundary, boundary of disk [indiscernible]
radius 2i. So my path is less than 2i. And if it’s some other terminal which is close to me, so I know it’s
close to me so again I need to pay at most O of 2i to connect to that guy. Okay?
So for s and t to get connected to their witnesses you pay a cost 2i so this means that if these two
witnesses, if they are actually connected before this iteration then I have a contradiction. But if you put
these 2i’s together this would be less than D my shortest path. So actually whenever I am buying
wherever I have this iteration, that I actually bypass the witnesses, I am reducing the number of
connected components. So again I can do the same old argument and say that okay I can pay that with
the disks here. So the number of actual iterations that I do are actually close to the, I mean O of the
number of actually I put twice the number of clients in that layer. Okay?
So if for every type i iteration my cost is in O of 2i and Mi is also paying almost 2i, so my cost is bounded
to the cost of Mi. Now since my cost is bounded to the cost of Mi I know that because of the property in
my black books, it’s bounded to the factor of log2 to the cost of my optimum solution. So this means
that I pay at most log3 because I have log n layers. Good?
So just to wrap up, so we are using this painting as framework which helps a lot in simplifying the nodeweighted kind of Steiner connectivity problems. This might help us in some other problems. Also, you
can also generalize these results for [indiscernible] variants.
>>: So when you say, so when you say [indiscernible], you mean something more than just
[indiscernible]
>> Vahid Liaghat: It’s [indiscernible].
>>: [indiscernible]
>> Vahid Liaghat: Well one fact is that you shouldn’t, so one thing that we kind of insist on it is that you
shouldn’t marriage these nodes. So you shouldn’t have these dual nodes that you marriage them to
each other and that makes things very hard. That, well things get complicated and that would be hard
to formulize. Especially the whole thing that we are insisting here is that these disks, you don’t need to
mix them, especially for node-weighted and this actually helps in some sense. That’s the whole thing
about [indiscernible]. The thing that we were saying okay is new compared to the node [indiscernible].
>>: [indiscernible]
>> Vahid Liaghat: Essentially. Connect them [indiscernible]. Don’t marriage them in this sense.
>>: Right, okay.
>> Vahid Liaghat: And that’s, thank you. So any questions on any part?
[applause]
>>: Any more questions? [indiscernible]
>> Vahid Liaghat: There is a kind of, for node-weighted, for node-weighted you can actually get ….
>>: [indiscernible]
>> Vahid Liaghat: [indiscernible]
[applause]