>> Mohit Singh: Welcome everyone. It's my pleasure to introduce Ola
Svensson from APFL. Ola works in approximation algorithms. [Indiscernible]
some very nice algorithms. And today he's going to tell us about one more.
>> Ola Svensson: Thank you. Good to be here. Yes, I will talk about the
new approach for approximating ATSP which is a classical problem. And then
we'll see some applications and some special case of metrics. So you know, I
think most of you know the problem. But let me start with some nice
geography. So suppose you want to find the best ticket from Lausanne where
I'm working to Lund where I'm coming from. You know, you can go to -- what
do you do? You go to the web. Fill in the proper details. Then you push
like the search button. Then you need to have some patience. This says
algorithm working in the background. Then you should find some good ticket.
Okay. Maybe €200 will be the price.
>>
What website is this can I use?
[Laughter]
>> Ola Svensson: Check my home page. There is a bank account number. Yes.
It is an easy problem because it's the shortest path, right? Shortest path
for this afternoon, but you could spice it up. So suppose you want to visit
all these cities. Now we ask ourself, what's the cheapest way to visit all
these cities? So what's the shortest way? That's one possible solution.
And of course it's the TSP problem. But we like a lot and many books have
been written about it. Yeah. So I would say you know one of our classical
benchmark problems compute size both from theory and heuristics. It's been
studied actually from the 1800s. That's where you get the name Hamiltonian
cycle, from Hamilton. And you know, even though on the study, I think it's
still a [indiscernible] with efficient computation in many areas, both
heuristics, this whole bigger and bigger instances, but also from
approximation algorithms. So in basically two variants and we don't have a
good understanding what we can do with these two variants. And the two
variants that we have, that's the most simple variant. We assume that we
have symmetric distances. So you have -- if you go from U to V, it's the
same distance to go from V to U. There you have the famous [indiscernible]
1.5 approximation. It's like a four tier algorithm and still the best.
Maybe, I don't know if the only algorithm he did, but it's a good algorithm
to do it. So it's 1.5 and it's still the best. Then you have the symmetric
case. So it's more general because we don't make an assumption that the
distance is symmetric. But you still have the [indiscernible]. And the
distance, the more general problem would be the focus of this presentation.
So maybe some people find it hard to model the asymmetric TSP. Like this
more natural with symmetric distances maybe. So let me spend one final slide
on why you should care about the asymmetric TSP. If you don't feel it's
natural symmetric, you should come and visit LaSalle. It's extremely hilly.
So you can see there's a big difference of going uphill to downhill. Okay.
So now you know it's a nice problem. So let's look at the definition. So
input, one way of defining this as follows. We have input, an edge-weighted
digraph. And so here is our input. And we have length. You should think of
this as one-way streets. And on the edge, we have the length of the street.
So it's 1, 3, 1. Now it's asymmetric, this might be 5000. And the goal is
to find a tour that visit each city at least once. So note that I'm allowing
myself to visit each city many times. Okay. That's necessary. Or it's
equivalent [indiscernible]. Otherwise the problem is extremely hard. Cannot
do it. Okay. So we want to find a cheap tour that visits each city at least
once. So if we define this in equivalent way using graph theoretical
notions. So what do we want to find? We want to find a subset of edge.
Yes? So that the graph is connected because we want to find -- we want to
visit each vertex. And it should be Eulerian. It should correspond to a
tour. Here Eulerian is N degrees equal to [indiscernible]. And that's an
equivalent formulation. So that's what one point find minimum weight connect
Eulerian multigraph. So I write multigraph because I'm allowed to use the
same street many times. So you can have same -- you can have many copies of
the same images. So that's the problem we're going to work with. Any
questions? Okay. Good. So we want to device [indiscernible] problem. So
we know one way. And that is to formulate nice relaxation, often referred
Held-Karp relaxation. And [indiscernible] comes quite natural. So you have
a variable for each edge, but you think of in the intended solution, this
variable should equal number of times you would pass this edge or you
cross -- use the road. So then the objective [indiscernible] that you
minimize total sum, the weight of the edges and the number of times used
edge. And then you have to write down that you want the graph to be
connected Eulerian, so Eulerian [indiscernible] you have a constant for every
vertex. This means the sum of all the edges going up from the -- should
equal the sum of every -- sum of the edges going in. So that's Eulerian.
And then you want to have that is connected so you avoid any
sub[indiscernible]. If all the subsets of V, you have a [indiscernible] one
[indiscernible] image. So this is also called subtour [indiscernible] you
want to avoid subtours. Okay. Yes. So that's the relaxation. So now the
name of the game is we can find a solution here, how do you massage it into
an integral solution without losing too much? Okay. So I would like to -so how do you do? So I think there are at least in theory at least two
available approaches of rounding this [indiscernible]. And they come by the
intuition that we have two sets of constraints. So [indiscernible] completed
[indiscernible] the red constraints. I forget about them. Then what is the
LP? The LP says find an Eulerian graph that is cheap. That's because
[indiscernible] of time. Of course here you can put everything zero, but
think about everybody that has degree one. That is mean across cycle cover.
So then we get the [indiscernible] time solvable problem. If we struck one
of the red set of constraints, then you won't find a mean cost Eulerian
graph, [indiscernible] cover that's not more response than a tour. So then
it's easy to finds Eulerian graph if I don't have the connected graph. On
the other hand, if I drop the Eulerian conditions, then basically I won't
have a connected graph. That's also easy, right? You can find a spanning
tree. Okay.
>> Actually, if you drop the red condition, isn't the solution actually
[indiscernible]?
>> Ola Svensson: Yeah, yeah. So everybody has at least one incident.
That's also an easy problem. But it's even easier if you drop the red
constraints without [indiscernible] the other. But yes, keep the constraint
that every vertex has to go least one. That is also an easy problem.
Otherwise, yes. Okay. So either you maintain Eulerian, but then you drop
connectivity and you try to fix it, or you drop Eulerian, you get connective
then you try to fix the [indiscernible] one. So let's see what kind of
algorithms you get by looking at the problem that way. So if you drop
connectivity, well, then you get this very nice easy to understand repeated
[indiscernible] algorithm. We have our graph. Now find mean cross cycle
cover. That has cost the most. It's not so hard to see because of this one
specific cycle cover. But the graph is not connected so what you do is to
find a representative in each component. Signed a cycle cover, cost at least
at most, again at most [indiscernible] repeat. Okay. So here you have total
cost at most three times over. So you have basically approximation guarantee
[indiscernible] you repeat. So now, if you are really unlucky, all your
cycles will always have length to. So you [indiscernible] load based to an
approximation algorithm. So now you think, okay, I should not be really
unlucky all the time, right? So you should get some cycles of length for
non- -- like in a significant fraction of the time. That is really hard to
prove. So this was very nice initial paper by [indiscernible] analyzed this
procedure so it showed that is a load-based to approximation and it took
20 years for Blasa to somehow ensure that you're not always get cycle of life
too. So you get say 99 log base two.
>>
[Indiscernible] the different algorithms, right because --
>> Ola Svensson:
>>
Yeah, yeah, yeah.
Yeah.
Okay.
It's not so unlikely that [indiscernible].
>> Ola Svensson: Good, good. There are examples where the algorithm
[indiscernible] where you're not save of select cycles gives you
[indiscernible].
>> And not [indiscernible]. If the distances vary widely, then it's in your
interest to find really, really small cycles. [Indiscernible].
>> Ola Svensson:
>>
Why?
Why should I find small cycles?
Because they're cheaper.
Because you don't have to --
>> Ola Svensson: [Indiscernible]. Yeah, but they all just of the same
lengths and the top because it's always [indiscernible].
>> Yeah. Sure. But if -- I mean, they're graphs. They're a way to graphs
where this algorithm will do exactly [indiscernible].
>> Ola Svensson: Okay. Yeah. So okay. Good. He changed his algorithm
slightly but it's still amazing to me that it's -- I mean, I'm not saying
that -- it is really hard. But it's kind of amazing I think that it is hard
to not do [indiscernible]. And the best here is by Mohit and if they gets
the 767, right? [Indiscernible] to an approximation using these techniques.
So by [indiscernible], the cycle is [indiscernible]. Okay. So that's the
first point of view. Now we can also try, okay, so we tried here. It seems
to be hard to do significant [indiscernible] so what we can do is try the
second point of view. So it's easy to find a connected graph. So that's the
same thing as in [indiscernible], right? If you are knowing the symmetric
case, you find a spanning tree, then you crack parities after finding a
spanning tree. That's the 1.5 by [indiscernible]. But now, let me
illustrate that this is also pretty hard for ATSP. Okay. So what I want to
say is that in [indiscernible], you can find a mean cross spanning tree,
right? And you can always correct it in a cheap way, by paying it most
[indiscernible] over two. ATSP, the situation is very different as we will
see here. So let's look at this example. All the blue edge you should think
of as being for free. The red edges are really expensive. So basically we
want to -- if we want to find cheap tour. We only want to use one edge, one
red edge. That's the best tour. Okay. So let's try. So our algorithm is
to find our spanning tree. That will be a spanning tree like that. Okay.
For example. That's a mean across spanning tree because the blue edges are
cheaper than the red. And now we have to verify the correct parity of these
two guys because this is alt degree one, zero. This is in degree one
[indiscernible] is zero. And if you think about it, the cheapest way of
doing it, you only need to use one red edge and about the blue edge. So
everything's great. You got the best tour. Okay. But let's now start with
another mean cross spanning tree. It's the same cost. So [indiscernible]
cross spanning trees. Now let's look at the [indiscernible] that we need to
correct the parity of. It turns out to be these. And now if you think about
for a while, you can see that you actually need to use all the red edged to
correct this, which is a bad thing. Okay. So if you make this example
bigger, this can show that even if you start -- you cannot start with over to
mean cross spanning tree in asymmetric case. You need to have some further
conditions. And there is a big in contrast to symmetric case is what to do.
And then there was a very nice paper by Asadpour, Goemans, Oveis Gharan,
Madry, Saberi who formalized what do you actually need to get -- what -- so
we want the span tree to be cheap, right? But this example shows that we
need another example for this tree to be good for ATSP. And continue as
efficient condition is often called fin crease. It's not necessary, but it's
efficient. Okay. So it's a nice graph theoretic problem which is actually
on weight. Suppose you're giving a KH connect the graph. A classical
[indiscernible] says that if we're given a KH connect the graph, then we can
find at least K over two did he say joints span Chris in that graph. Okay.
So if I look at one cut in that graph, then there exist a spanning tree using
at most two edges crossing, right, if I fix one cut exists the span tree only
using two edges.
>>
[Indiscernible].
>> Ola Svensson: Two [indiscernible]. No. No. No, okay. Yeah. Okay. So
let's fix the [indiscernible] size K. Then there -- clearly there exists a
spanning tree using two OK. Otherwise, if we figure already [indiscernible]
two over K, fine. Perfect. All right. So now what does the thin tree
promise us? Well, find me for tree that is simultaneously good for all the
cuts. So you don't fix the cut before selecting a tree. Now you select the
tree and it should always be good for all the cuts. Okay. And here, alpha
is the parameter. So clearly alpha has to be at least two. I don't know if
we said before, but for what can we do of? So we want to find a tree that is
simultaneously doesn't use much more than alpha over K. It shouldn't use
more than alpha over comfort fraction of the edges. And this turns out to be
sufficient condition because then you can use [indiscernible]. So without
going to this, if you have a procedure that far [indiscernible] alpha thin
tree, then it actually gives you an alpha [indiscernible]. So that is a
sufficient condition to approximate ATSP. Okay. But this condition also
turns out to be a little bit hard to analyze. So in their very nice paper,
log in and log [indiscernible], then they showed that [indiscernible] run on
tree [indiscernible] solution according to good distribution. Then I will
have -- then I can select alpha to be log in over log [indiscernible]. Okay.
Which is the [indiscernible] of pod. So this gives you a log N
[indiscernible] approximation. Then for special case of plain or
[indiscernible] graphs, they can show that exists constant thin trees. It's
good. And then is a really nice [indiscernible] by Nema and Cheyenne, who is
also here other weeks but this week. Who showed us actually there exists
always a [indiscernible] log log and thin tree. Okay? So there always
exists such a tree. So this implies that the equality is at most poly log
log N. [Indiscernible] set of proof at the moment is not constructive. It
also relies on [indiscernible] proof of the [indiscernible] which is not
[indiscernible]. Okay. So at the moment, it looks like the red approach is
much better than blue approach. So now I will present a new approach that is
more similar to the blue approach, so maybe it's the come-back of the blue
approach. We will see. So to summarize, best approximation is log in
[indiscernible] log N [indiscernible] log log N but the best [indiscernible]
is two. And even more encouraging, everybody I know that worked on this
problem believes two is maybe -- probably the right answer. Like any at
least a constant. I believe in two. But everybody [indiscernible] believe
in a constant. Okay. And I should say here, so there's no better guarantees
for shortest path methods on weighted graphs. So suppose all edges in the
initial case are the same length. Then we don't know any better guarantees
than log in over log log N or poly log log N [indiscernible]. And this is in
contrast to symmetric ATSP because in this instance, we know better than
[indiscernible]. So there was this sequence of papers, the last one by
[indiscernible] 1.4 for shortest path metrics. And it's not clear how to get
anything better with these approaches for ATSP because you know in this -- if
I could convince you the main difficulty in cycle approach was
[indiscernible] number of iterations and in the thin tree approach, we
actually reduce to the unweighted platform. So it's not clear how to use the
shortest path metric. But if you manage to use these approaches there, you
will probably solve the [indiscernible] problem. Okay. All right. So
what's our new approach? Okay. So remember, how we present, we have done
alpha with a blue set of constraints and a red set of constraints and we got
the two approaches by dropping one of them. Okay. So what we will now do is
to keep the blue constraints but also keep a subset of the red constraints.
For specific subset S of all the cuts. And why do we do that? So we still
want this problem to be easy to solve but by introducing some cut
constraints, we can hope that we can patch up the unconnected components by
not paying too much. So if we have some control over which cuts to satisfy,
this can lead to less cost when we patch things together. The best idea. So
we somehow -- so the cycle cover approach, it was trivial to find a cycle
cover, but it was very expensive to patch it up. Now we make each iteration
a little bit more difficult. Okay. Not as is cycle cover, but the hope is
that this difficulty will help us patching it up cheap. Okay. And the nice
[indiscernible] using this is so if you have the shortest path method so
[indiscernible] graph [indiscernible] 15. We can also get the
[indiscernible] 27 approximation algorithm. So what this node
[indiscernible] shortest path metrics. So here, what I mean is that every
vertex had a node weight. 1, 5, 2, 1, and the length [indiscernible] when it
goes out. The length of this is two. Length of this is five. 5, 5. Of
course it's not the complete graph because [indiscernible] easy problem. So
the length of any is not present in the graph is the shortest path. So this
generalizes the shortest path which are on weighted graph that was considered
the symmetric TSP. All right. In this case, the value of the tour is
[indiscernible]. Yes, I have some example, you know, from intuition from
node weight. Suppose you want to visit all these cities, then you have
different ways based on where you want to go more often. So I like Chicago
and Boston, but so I visit them in January. This January. And will I'm from
Sweden, but I have never seen something like that in my life. It was so
[indiscernible]. Also, there is a more serious motivation maybe. It's not
too far away from general metrics. Because the metrics that we actually need
to solve for this problem, if you use the [indiscernible] that we use, has a
very special structure. So the edges that appear in our graph, first of all
you will have a laminar set family which a value for each laminar set. So
suppose this set has value one, this has two, this four, and this three. And
now, the length of an edge would basically be the sum of the values of the
sets it crosses. Okay. So in our case, basically what we have taken is a
laminar family where only have the single outputs. If you would have a
general laminar family, then it would be general metrics. Okay. So this is
the situation for symmetric. For asymmetric, be there is two kind of sets.
If it crosses as going out or in. But basically, this is the situation. So
general metrics have also very nice structure if you use this
[indiscernible]. [Indiscernible]. All right. So what did we do? Yeah. So
our approach, so remember, idea was to find a smart C for which we can solve
this problem. So let me now define what kind of subset of constraints what
we are considering and what the problems did we solve. And we call this
problem local connectivity ATSP so input is an edge weighted. The input is
ATSP instance. Okay. The same as ATSP. But now you are also given a
partition of the vertices. So here you have ATSP instance and a partition of
the vertices. And now, remember that we always want to find an Eulerian at
the edges but also satisfying some cut constraints. So cut constraints we
want to satisfy is that each cut defined by partition should have at least
one edge crossing it. That's the only thing. So here, one potential
solution will be this. It's an Eulerian subset of edges and I cross each
cut. So that's the kind of cut constraints we want to satisfy. We want to
find Eulerian set of edges that cross [indiscernible]. If I have a single
[indiscernible] in my partition, then I [indiscernible] cycle cover. But if
I don't have a single [indiscernible], then it's different. Okay. That
looks like easy problem, right? At least for me, it looks pretty easy. So
the thing that makes it not too easy is our objective function is also a
little bit harder than the ATSP objective function. So in ATSP, you sum up
the weight of all edges, right? So here, our objective function says that
each component should be cheap. Okay. So let me define this in the
unweighted sums first. So that it makes sense. So we say that an algorithm
for this problem is alpha light with always output a solution F. So at each
component satisfies the number of edges over the number of vertices most
often. This make it locally, it looks like a good tour. If we look at the
component here, okay, I visit two vertices. I use two edges. That's a
perfect tour. Alpha is one. If I look at this vertice here, this component
here, I use six edges and I visit five vertices. So it's like a six over
five approximate tour. And what I'm saying is that it's an alpha light
algorithm if each component locally is an alpha approximate tour. Okay. So
here's 1, 6 over five. So yeah. Actually, so yeah, so what we can note
here, any questions from that definition? So I want to find a subset F that
crosses each cut. And each component should be a good tour. Good here alpha
approximate tour. So why is this easier than defining an alpha approximation
for ATSP? So suppose, you see that? Suppose you have an alpha approximation
for ATSP. What can you do? You run that. You get the whole tour that has
alpha, that is alpha approximate. Clearly that is a component -- that's the
only component you have to worry about. So that's the solution. Okay.
Okay. You can also generalize this definition to a general way. But people
tend to get confused here. So let me skip it and remaining of the talk,
let's worry about unweighted graphs. Okay.
>> Just the condition before this, the condition is that it has to connect
to all these pieces.
>> Ola Svensson: To the partitions. It has to cross. There has to be, you
know, each cut defined by these partitions, one edge has to go out.
>>
So each cut where you put some of the parts [indiscernible].
>> Ola Svensson:
>>
Yes.
So it's very similar to the log N approaches except that [indiscernible].
>> Ola Svensson:
Yeah.
Yeah.
>> [Indiscernible] any edges, and they also say, okay, one edge over this
cut but only [indiscernible].
>> Ola Svensson:
Yes.
>> So it's the same as -- sorry. It is the same as saying if you put a
[indiscernible] on each part over the partition, then the resulting graph is
connected, right?
>> Ola Svensson: Yes. Okay. That's a little bit misleading. So right now,
we found a tour here, right. I don't require you to find tour that the graph
is connected. That I don't require. I just require that each cut is
covered. So it's weaker.
>> So it's not going to [indiscernible].
could have two [indiscernible].
This picture is misleading.
You
>> Ola Svensson: If I remove this here, this here will not need to be there.
Because then it's ->>
Oh, because then [indiscernible].
>> Ola Svensson:
Yeah.
Yeah.
>>
[Indiscernible].
>>
He's only taking one of them on one side [indiscernible].
>>
[Indiscernible].
>> Ola Svensson:
and this cut.
>>
I see.
[Indiscernible].
>> Ola Svensson:
>>
Yeah.
I could have removed the -- yeah.
[Indiscernible] edge coming out of that or --
>> Ola Svensson:
>>
So the cuts, I worry about this cut, this cut, this cut,
[Indiscernible].
But you do pay for this [indiscernible].
>> Ola Svensson:
Yeah.
>>
[Indiscernible].
>>
[Indiscernible].
I pay for all edges.
>> Ola Svensson: Yeah. Yeah. So as I did here, I picked some edges inside
my [indiscernible]. Okay. Good. So, yeah, it's easier, but my main testing
result is if you can solve this problem, then you can solve the ATSP problem.
If there's an alpha [indiscernible] ATSP, then [indiscernible] ATSP
[indiscernible] and nine alpha approximate tour can be found [indiscernible].
Okay. If your algorithm for [indiscernible]. So this seems to give the
power to patch things together. Okay. Now the problem -- okay. So we have
an easy free light algorithm for node weighted metrics. That's why we have a
node weighted. So you could generalize the definition of local connectivity
just be to general metrics. But the only place where we can solve it, where
we can solve the -- where we can define an alpha light for constant alpha is
node weighted metric. So that's why we have -- there are free lights so this
gives you the 15 and 25 for node weighted metrics. Okay. So this free
light, if you have -- like this is at least for unweighted graphs. Right?
Like find a sign cover. That's one light. Now we have to do some stuff when
you have general partitions but it's kind of not too amazing to think that
there is not too hard algorithm for that case. So let me skip that and let
me worry about how to prove this theorem, how to use this power to patch a
tour that's not too expensive. Okay. So what's the proof ID? Okay. So the
first approach would be a little bit what Mohit hinted at. Well, we have
something that very much looks the log N. So we start with a completely
unconnected graph. We saw a local connected ATSP with the partitions, with
the single [indiscernible] partitions. Then you get some, right, you get
something that has every vertice has [indiscernible] at least one. And this
guys are cheap. This costs you at most opt. Alpha opt. Because it was
alpha light. Okay. So now we have connected that. So now we can run local
connectivity ATSP on this partition. So you find this set of edges. Okay.
So again, you pay alpha opt. Because that's not good. So here, okay, it was
good because you only run two iterations but again, but if you do that, then
the [indiscernible] number of iterations times alpha times opt so it's even
worse than we had before. So that's not great. So we have to do something
special here. And I think what the most special thing is our initialization.
Initialization is also why we have this two different result for polynomial
time and not polynomial time. So let's -- what is our initialization? So we
do some lexicographic initialization so here, I have the graph
[indiscernible]. So of course we're going to use that we have our alpha
[indiscernible] SSP. So what I will do initial session is to think about I
will select the biggest cycle in the graph. And this will be my starting
point. So my first thing I select is H1. I call it H1 store. That's the
largest connected component pass to alpha light tour. Of course, if there is
a two alpha light tour in the whole graph, this is the whole graph and we
solved the problem. That's why we have the non-polynomial and the
polynomial. Okay. So that’s my first component. Why do I do that? So
let's look at F. If that's Eulerian subset of edges that is alpha light,
then I claim that the number of vertices, the number of edges in F is the
most alpha times the size of the number of vertices in H1 store. Why is
that? So you know that F is alpha light. Number of vertices in F, number of
vertices is at least F over alpha, right? Because it's alpha light. So if F
is greater than alpha times V1 store, that means that F is alpha light and
also contains more vertices [indiscernible] store. But that contradicts our
starting point. We started with the biggest component that contained a two
alpha light tour. So then F should have been our H1 store instead. So
that's what [indiscernible]. So we know that everything that is alpha light
that intersects H1 store has cost at most roughly B one store.
>>
So [indiscernible].
>> Ola Svensson: Yeah. Okay. Good. Yes. It doesn't [indiscernible].
That's good. Okay. That comes in next picture. So now H2, H1 still was the
biggest guy. Then I remove it. Take H2, start with the biggest guy in the
remaining graph. Now I say if F doesn't intersect H1 then it has crossed at
most alpha times V two store. Otherwise I could have replaced VH to store
with F and I will get the [indiscernible] lexicographic order. Okay. I
might do this. Okay. The last guys might be single [indiscernible]. Okay.
That's my initialization.
>> And I'm sorry, connect this component?
graph?
>> Ola Svensson:
>>
Connect the component of the
Yeah, yeah.
So how can the two intersect like that if it's connected?
>> Ola Svensson: So think of this as a cheap tour.
of the longest length in the graph.
>>
Think of this as a cycle
But when you say connected component, what --
>> It's connected but not [indiscernible]. So the whole graph
[indiscernible]. This is the largest of graph which is connected and is this
property.
>>
[Indiscernible].
>> Ola Svensson: I see, I see, yeah, yeah, yeah. It's not the connected
component. Yeah, yeah. Good. It's if I induce on the vertice in V1 store,
then it has a tour of side two alpha. So forget about connecting components.
>>
Are you claiming you can find such a thing?
>> Ola Svensson: No. That's what I'm saying. So I'm claiming that of
course if I could find it, then I would just change 2 to 5 and I would be
done. So that's why I have these two different factors. 3 and 9. Yes.
Good. Good. All right. So now we have any more questions on
initialization? Okay. So now, we have our initialization. It costs us two
alpha times opt because each component is two alpha light. We have a tour
here using two alpha more than the [indiscernible] the vertice. So what
would our wish list of the merging step be? Suppose we could connect the
graph but we only want that alpha light components. Okay. So that we short
V H1 store at most once. So this guy, he intersects V1 stores. We know that
he has cost the most alpha V1 store, right? By the previous (inaudible).
This guy, he intersects, the biggest guy intersects his H2 store. So we know
that this guy, he has cost at most alpha V two store. This guy, he
intersects -- the biggest guy intersects H3 store so he costs at most the
alpha V free store. And so on. Okay. This is at most alpha V. So if we
could do that here, I show H1, H2, H3, and H -- for distribute H five. This
should be H five. So shorts everybody at most once. Then I would be happy,
right? Because then I will get two alpha or plus another alpha because I
short everybody at most once. Okay. So that would be an ideal situation
where we would short everybody at most once. Okay. So that's unfortunately
not completely true. So let me explain how we do it by looking at two
extreme cases after the initialization. So first extreme case is that after
initialization, all my starting components were exactly the same size. They
were -- oh, it should be opt over K. It should be opt over -- N over K
because we assume -- should be not opt. Yeah. N over K. So everybody is of
the same size. Okay. Why is it easy problem? Do you see? What this is
size of any alpha light graph, alpha light subset of edges in our graph. Is
at most size B one stop, right? This is opt over K. And now, how many such
guys do we have to add to connect the graph where we have to add at most K
minus one. Like we have to find like a connect the graph with K components.
We have to add at most K minus one guys. And each guy has cost opt over K.
Okay. So we have to -- so here we add these are alpha like guys and we
[indiscernible] four plus six to [indiscernible] K minus one guys. But
everybody, you know, that every -- that is what we proved before that
everybody has site at most V1 store with this opt over K. We added K minus
one money. So in this case, you actually get alpha to patch thing together,
plus the initialization was two of. So this is a very good case where the
initialization actually resulted in even size components. All right. So
let's look at opposite case. After initialization, you got this huge guy and
now we have all these small guys. All right. So now we solve the local
connectivity ATSP as we know we can do. So now, everybody gets to the big
guy right? That looks problematic. Now I can only say that this guy is at
most V1 store, this is at most V1 store. So I will get a horrible
approximation here. Okay. So here is the second claim. When we have such a
thing, then the claim of the red edges is at most two alpha V1 store. Okay.
And why is that? Okay. Think about this. So the red edges, there are many
more than V1 stores. So at least the red guys, they contain two V1 store
vertices because they are alpha light. The red guys are alpha light so they
contain two V1 store edges. Vertices. They cover two V1 store vertices with
more than H1 store. So let me do it here. So what we will do is to consider
graph H store. The union on H1 store and all the red guys. H store is the
union of H1 store and all the red components. Okay. So now we want to
calculate what's the number of vertices of this guy? Well, it's at least two
V1 store vertices. It has all vertices, let's say always number of vertices
in this red components, at least two V1 store. Okay. This is alpha light
and it was -- it's -- it was -- we are supposed to watch contradiction of the
bigger to alpha V1 stores. It has at least two V1 vertices. And now, how
many edges does this graph have? It has -- we know that H1 store was two
alpha light. So H1 store has two alpha V1 store edges. The red guys are
alpha light, so they have at most alpha times R edges. Okay. So it has at
most two alpha V1 store plus alpha edges. Now if you divide this by R, well,
here, you get at most alpha. This guy is bigger than two V1 store. So here,
you get at most alpha. Here you divide by R, so you get alpha. So this
means that in that case, each store was two alpha light. So if we suppose
that the sum of this was bigger than two alpha V1 store, then H store itself
plus two alpha light, and it clearly is bigger than H1 store. So this would
also be a contradiction to the initialization. So the clear that one of them
is at most V1 store, but what's nice is that actually the union of them is at
most two V1 store. And that's what we use here. Okay. So now, of course,
we are happy. So here, it's four of. So okay. So this was two extreme
cases. And the final five actually comes because you actually have to
somehow combine these in a clever way. So you get two alpha from
initialization. You pay alpha for the first case and two alpha for the
second case and then you get five. Okay. But I stopped for something the
whole merging because people found it not so intuitive. But it gets a little
bit -- yeah. It's kind of short but it's a little bit -- you have to be
careful in which order to add stuff. Okay. So open problems. Let me finish
with. So we have presented a cost-effective for node weighting ATSP. And I
set up the shortest path metric for TSP, [indiscernible] but what about node
weighted TSP, metric TSP? So that is now defined as I have a weight for each
vertex. The distance of the edge is the maximum of [indiscernible]
endpoints. That's a special kind of metric. And here, I've been thinking, I
think some people are thinking, here we don't know how to do better than
Christofides. So this is somehow in between the general metric and the
shortest path metric on weighted graphs. I think it's a good open problem.
But, yeah. I will be very interested in the solution. And then obviously
there is this constant for ATSP on general metrics. So either you can find a
thin tree or you can solve this local connectivity ATSP in the general case.
That's the two approaches we know. Of course there can be other ones. Okay.
So what did we do? I explained existing approaches. Then we had a new
approach that relaxed connectivity. And actually, you can improve it a
little bit. So instead of having 15, you can get 13 for node weighted, but I
have no idea -- two seems to be the right number and I don't know how to get
there. And there's nice open questions in both cases. Okay. Thank you.
>> Mohit Singh:
>> Ola Svensson:
>> Mohit Singh:
>>
Questions?
What's that problem?
Okay.
Questions?
So [indiscernible].
>> Ola Svensson: Actually, so this -- I don't know where it is. The main
tactical theorem. That's what you're referring to, right? It's actually
that is very general. So the only thing you need to do -- sorry. Where is
this? Here. Here. Here. So here, we had a number of places over the
number of vertices, right? So the only thing I have to change is the weight
of edges and then you have an assignment of ways to the vertices. So this
LBB prime is just -- I have an assignment of weight. The cross
[indiscernible] pays for this in this vertex. And the main theorem holds as
long as this is a non-negative function and it's total sum of weight assigned
to vertices of most alpha light. So you can assign it as you want. But the
question is now, one, you have assigned this weights. Can you solve
[indiscernible]? But you're free to assign them as you want. So node weight
to be at stake, it's natural to take that the amount you pay for vertex is
simply the number of edges going out from it.
same weight.
>> Mohit Singh:
[Applause]
Any questions?
Because edges there have the