 Okay, so let's start. So welcome to TCS Plus. Today's talk is by Yola Svensson before we introduce the speaker. I'll briefly, I will go over the audience. And so the first group is from, sorry, the first group is from Columbia, by Columbia, then from Stanford, or Stanford, and Kavchen is lead, the group from Michigan, Michigan State. Then Sahaan, I do not know where this group is from, maybe one of you can introduce yourself. Well, then we have the group from UCSD. Hello. The side from Shahid Behesty University, Shavasraha from NYU, Bagan from MIT. So we are going to, I guess some groups will trickle in as the talk proceeds. So today's speaker is Sola Svensson. And Sola is at EPFL. And he has done break through work in traveling assessment problems, scheduling problems, and the complexity of matching, and has received several best paper awards for these works. And today he's going to talk about a constant factor approximation for the ATSP problem that's resolving a decade-old problem. Before we start to talk, I would like to remind you, in a week from now, so not two weeks, in a week from now, we'll have Vinod Vekon Natans, so at DCS+, and then we also have John Kellner lined up two weeks from then. So, Ola, welcome. Oh, okay. Thank you very much. It's a pleasure to be here, as always. So this is joint work with Jakob Tanasko, who is also at EPFL, and with Las Lové, who is at LSE, London School of Economics in London. So this is me, if it was fun to put me at the same level. So let me just move me up so you can see the slides. All right, so let me start this presentation by answering a question I think most of you have asked yourself. And that's like, what's the cheapest possible way to visit the 24,978 cities of Sweden? So would you guess how long would the distance be to visit these biggest cities of Sweden? I guess it's hard to get it interactive, but thanks to Applegate, Vixby, and others, we know that this is, you know, you can visit these cities with 72,500 kilometers. Okay, so they saw the optimal tour, how to visit the 25,000 biggest cities of Sweden in 2004. And they did this using a heuristics based on a linear program, the same linear program as we will use. So this is a fun example, because I'm from Sweden, and Sweden has only 9 million inhabitants. So it's very impressive, but at the same time, you have to be very liberal in your definition of what the city means. So this means, you know, I don't know how they identify that many cities in Sweden. Okay, so in any case, so this is the TSP problem, you want to find the shortest tour that visits and given cities. So here we have an example with seven cities. And maybe that's a tour. So this, you know, one of the most well-studied benchmark problems in computer science was studied in the 90th century by Hamilton and Kirkman, we know Hamiltonian cycle and so on. And several books have been written about this problem. And it remains, you know, we don't completely understand in spite of all this research. So it remains a big open question what efficient computation can accomplish. So when studying this question, basically two versions are studied. So the first one is symmetric. So that's where we assume that the distance going from V to U is the same as the distance going from U to V. Or the symmetric case where there is no such assumption. So it's more general. So distance from V to U could be free, but the distance from U to V could be 100. Okay. And that's the case we're going to consider today. So maybe at the first site, you know, asymmetric differences might seem unnatural. So let me have one slide motivating this. And the answer is if you're not so, if you're not so convinced, then you could come and visit Lausanne, because, you know, there's a big difference going uphill than downhill. So there's a very difference going, you know, in one direction to the other one. You could also think about skiing or one-way streets. Okay. So now, now you're convinced that it's a very important problem. So let's look at the formal definition. So we have an input and edge-weighted digraph with vertex ZV, LZE, and a weight function W. So in this example here, this edge could have a weight one, weight E, you know, you should think of weight to be cost or distance. So here the weight is free. And here it's one, there it's 5,000. So it's asymmetric. Then the goal is to find a tour that visits each vertex at least once. So, you know, maybe normally when you see the definition of TSP, you insist that you should not only visit each vertex at least once, but you should visit each vertex exactly once, right? That's a standard formulation. So the reason that they formulated as vertex at least once is because this is equivalent to assuming the triangle inequality. If we do not assume the triangle inequality, we cannot hope to do anything, okay, even in the symmetric case. So in all the works that I will mention, and what we will consider, we assume the triangle inequality, or equivalently, we will assume that we can visit each vertex at least once. So that's the definition. It will be convenient to look at an equivalent definition that is a little bit more graph theoretical. So instead of looking for a tour, we look for a minimum weight. Ola, can you just pause for a minute? Guys, I think somehow because of something, we are having only 10 people allowed, more people were supposed to join. I'm trying to figure out if we can restart. I'm not sure what's going on. Maybe it's best to let the thing go. Okay, I'm not sure what's going on. Okay, actually, Ola, just maybe just keep going. Just keep going. Sorry for that. Just keep going. No worries. I keep going. So here, here it's, yes, so that's the formulation, right? And an equivalent graph theoretical formulation that will be easier for us to work with is that we are looking for an edge set that's a multi-set. So it might contain the same edge times, multiple copies. And now we want to look for a connected. This is that we want to visit every vertex. It should be a connected multi-set of edges that connects the whole graph, and it should be Eulerian. Eulerian means simply that the in degree should equal the out degree. That's clearly the case in a tour, and it turns out to be sufficient. So this is the graph theoretical formulation that is equivalent and the one that we will work with. So we're given an edge weight, the directed graph, and we want to find a minimum weight connected Eulerian multi-set of edges. Any questions? This is the formulation we're going to work on, so it's important that people understand this. So it needs to be connected, and it should have in degree equal to out degree. So in the symmetric case, this just means that the degrees should be even. Here in the asymmetric case, we need the in degree to equal the out degree. So now, if we have the problem definition, let's look at what's known. So here I will not talk about the heuristics that we saw in the beginning, and I will just focus my attention to approximation algorithms. We are interested in what's the best possible algorithm we can do with provable guarantees. And recall that the go approximation algorithm is an algorithm that is efficient. It should be polynomial time, and it should have a good worst case guarantee, meaning that on any input, we should always find a solution so that the cost of the found solution is at most raw times the cost of the optimal solution. So here if rho is equal to 1, then it's an exact polynomial time algorithm. And if rho is equal to 1.01, then the algorithm finds a solution with at most 1% higher cost. So we would like rho to be as small as possible. So let's now see what's known. And I just have to mention, you know, Christof Frieders worked for symmetric distances. So he gave a free house approximation algorithm in the 70s for that case. And this remains the best. It's a notorious open question, can we do better than free house? And this is an intriguing question also, because we believe that we already have a stronger approximation, at least of the optimum value. Okay, so Helcorp, they introduced in the 70s as well, a heuristic for calculating a low bound on a tor, which coincides with the value of a linear program. And the conjecture is that this low bound approximates the value within, in fact, the four thirds. Okay, so we believe that if we solve this linear program, we have a four thirds approximation of the optimum, but we don't know how to prove it. Okay, and we will see that the similar situation holds for a symmetric traveling seismic problem, but with a much bigger gap. All right, so sorry, that was about symmetrics. Let's go back to a symmetric. So here, the first algorithm with a provable guarantee was given by Frisk Albiatti-Mafioli. So it gives a log base 2n approximation for symmetric TSP. So I would like to emphasize this, this really a log base 2n, so no hidden constants. So the hidden constant here is 1. It's a very nice, beautiful, clean algorithm that I will have the chance to describe later. Okay, then we skip the 90s, not too much, maybe for ATSP. Sorry, maybe, I hope I don't miss some important results, so upset someone. So then in 2000, it was also proved that is ampere to approximate ATSP within 1.01. So it basically ruled out the possibility of a pitas, but that's far away from the log n approximation by Frisk Albiatti-Mafioli. This low bound was simplified recently by Kapinski-Lampis Schmidt to give a low bound of 75 over 74, but it's still very close to one. So at this point, the best algorithm was still the log base 2n approximation by Frisk Albiatti-Mafioli. And then in 2003, there was the first improvement, and that was to replace the constant 1 by constant 0.99 by Blaser. So yes, this might look like a small improvement. I imagine like one of the main motivations here is that if you set cover, right, it's a relate somehow looks like a relate the problem if you think about it for a while. And there it turns out that the natural logarithm is the exact ratio, but we can achieve in polynomial time. So this way this result here showed that log base 2n is not the ratio for ATSP. This was further pushed by Kaplan et al. And the best currently known ratio based on pushing the techniques by Frisk Albiatti-Mafioli. So all these papers pushes the same technique, which is based on repeated cycle covers that I will explain later. So here I think is the world record using that technique, which is two-thirds times log base 2n. Then in 2010, I think a big thing for ATSP happened. So then as a poor Goehmans-Madi over Skaren and Sabiri, they introduced a new approach, which is much more related to the Kastafidis approach, where you find a spanning tree. You forget about the in-degree equal out-degree constraint, you find a spanning tree, and then you fix in-degree and out-degree. To fix the in-degree and out-degree in ATSP, you need some practical fineness of the spanning tree that you find, and they show that you can find that property good enough to get the log n over log log n approximation. So that's also a very nice paper. So that was the status at 2010. So basically, we didn't really know what the approximate ability of ATSP is. So MPR approximates within 75 over 74. Best algorithm has a super constant approximation guarantee. And you know, this is pretty amazing because the only thing we know is that the standard linear program relaxation or helical relaxation from many decades ago cannot do better than two. And it was conjectured that it does a constant by Goehmans. I don't know if it conjectures a two, but maybe I can conjecture a two. Okay. Definitely, they conjectured a constant. So we knew that we had a linear program that should approximate this problem within a constant, but we didn't have the techniques to prove it. That seemed like a difficult problem. Okay. So I did a scientific comparison to illustrate the progress. So you can do the scientific progress. So let's say we have a log n approximation for ATSP in the 80s. That's how the mobile phones looked like that. Then you know, the mobile phones progressed very rapidly to 2010, the ATSP rates your progress much slower. And then we had this log n of a log log n, which introduced a new method. So now the hope is, can we use this assault to push further down the right? So to summarize, there was two approaches. And these approaches are motivated in the following ways. So remember that they defined ATSP as the problem of finding a connected or layering graph. The first approach forgets about connectivity. So let's just maintain that we always have an or layering graph. And it's easy to find a cycle cover. So we can find a cycle cover that connects part of our graph. Now we do a new cycle cover to connect the graph a little bit more and so on and repeat this. And you need to repeat that log base two n times to get your final solution. We will see that later on. The other approach based on Fincrease is based on, let's forget about the layering condition. Well, it's easy to find a connected graph, a spanning tree, and then we fix up the n-degrees and e-out-degrees. So that was a Fincrease approach. So after their publication, it was also used the Fincrease approach to get a constant factor approximation in the case of planar and bounded genome squares. And then more recently in a major developer, I would say, it was an exponential improvement in the boundary and integrality gap by Neymar Narin, Cheyenne-Oves-Göhan. And this used as heavy machineries. It used a generalization of the caresson-singer conjecture, which was proved by Adam Marcus, Nikkele Srivastava and Dennis Spilman. And therefore I write bound and integrality gap because it's not known whether this heavy machinerie can be done in polynomial time. So this gives a bound on the integrality gap of the linear program, implying a so-called estimation algorithm. We can estimate optimum value with this guarantee, but we don't know how to efficiently find a tor, a solution of this guarantee. Okay. And around a little bit later, around the same time, we also introduced a third approach to approximate ATSP. I call this local connectivity ATSP, so it's an issue problem in some sense. And this is more related to the cycle approach in the main, in the sense that you maintain a linearity and you work towards making the graph connected. And here we get, use this approach to get a constant factor approximation in the special case of node weight and matrix. Okay. So if you want to get a constant factor for ATSP, this looks like a pretty hard route to follow. A lot of smart people have tried this for a long time to get the cycle curve approach work to a constant. I will describe maybe one approach to make it work in constant later on. And the thin tree approach is more fresh, so this could be a viable route. But you know, what least people have tried is to work on this kind of method. Can we use that result to get a constant factor for general matrix? And that's what I, Jakob and I also tried and we worked hard. And what we ended up with is a constant factor approximation for two different edge weights. So then we thought like, okay, so we pushed this method to the extreme. This looks like really hard even to get up to like four edge weights or three edge weights. It was too complicated. So there we were a little bit depressed, but it turns out that now we could overcome those obstacles to get a constant factor approximation area for any metric with respect to this standard LP relaxation. So to unoptimize constant in the paper is 5500. You could optimize it a lot, I guess, but you could only get, I only would guess that you can go down to a couple of hundreds. Okay. So it's very far away from the lower bound of two. So here you would need very, it would, it's a very interesting problem to develop new techniques to get closer to two. Yes, we don't know. So I presented, yeah. Do we know something about like the Julian approach? Do we know like, oh, it cannot go further than some particular like multiple of login or, or it's still conceivable that it could go further down? Yeah. Yes. Good question. So I think the following is known. So if you always select a mean cost cycle cover in each iteration, then the analysis log base 2N is tight. So what they did to get like two third log T1, you're careful in the selection of the cycle covers, but you could imagine an actual algorithm is the following. You solve the linear program and you sample a cycle cover according to the marginals, according to certain distribution. This we don't know if that will work or not. It depends on which distribution over cycle covers you select. Depending on the linear problem. We just don't know how to analyze it. I will talk more about that later. You will see maybe there is a natural approach, but we don't know how to make it work. Yeah. So I presented this like we were stuck at two edge weight. So how come we could do the general case? So the main difference, maybe the key difference, high level difference between the two papers is that in the two edge weight case, we try to use this local connectivity approach for a general problem immediately, whereas here we present a sequence of reductions and each reduction gives more and more structure. And as I hope I will be able to convince you, in the end we will have so much structure so the resulting problem is actually easy to solve. Okay. So instead of trying to solve the whole problem immediately, we give you know a path of reductions and in the end of the day it's very easy. Oh, very easy. But you know this might look frightening. It's a long path, but I was like stressed that it's modular. So you know, I don't know what pirates like to do as a break, but you're going to take you, you can take some ROM and then you can take some, I don't know, some buffing break. So you can, it's pretty modular, as I will explain. Okay. So more seriously, this is the reduction. So first we would use to something we call laminated instances, then to reducible instances, then to vertebrate pairs. That was a word that I didn't know before this paper. Last was the inventor of the word vertebrate pairs. And then, then we have so much structure that we can solve it using local connectivity. Okay. So let me stress again, this is highly modular. You can read this one day, forget about most things, then read this one day, forget about most things, read this down another day, forget about most things, finally read this. Okay. And I try to do the presentation in the same way. So I will have this goldfish on the slide when it's something you should probably remember for the next time, for the next part. So I will not have time to, as I said, I cannot talk about the whole thing, but I will have time to, I think, to explain enough reductions so that you will see that we get the very structured instance that you can hope to solve. Okay. Any questions so far, except the psychocolor? So now I will start to explain what do I talk about, what's this laminated instances and how can we obtain them. All right. So the picture looks like that. So basically here we will use the amazing power of alpiduality to give a very nice structure on the weights on the edges. So you know in ATSP, right, you're given a graph with arbitrarily edge weights on the edges in the graph. Now we show to you that by alpiduality we can actually assume that the graph has a very nice structure on the edge weights. Okay. So we will use the linear program. So let me introduce the linear program. So remember we recall the definition we have a connected Eulerian multigraph. This means that the integr is equal to our degree. So now we will write the linear program based on this. We will have a variable for each edge. So x, u, v that equals intuitively the number of times we traverse that edge. Now you want to minimize the weight of your tour. So that's just summing over all the edges, the weight of that edge times the number of times you traversed it. Now the constraints should say that the solution should be Eulerian, meaning that the out-degree should equal the in-degree and it should be connected. So to write the out-degree we just say that the sum, this means that the sum of x values of the edges going out of v is equal to the sum of x values of the edges going into v. So that's a linear constraint. We write that for every vertex. And now to avoid sub tours, so we're not happy, we say that for every set S, we should have at least one edge entering S and one edge exiting S. So that means that if we sum up both the entering edges and the outgoing edges, we should have at least two. So let me define this notion. So maybe so I have a set S. Delta plus S is the set of outgoing edges. Delta minus S is the set of incoming edges. Delta S is just the union. So again, here I have the sum of x values that go out of v is equal to the sum of x values going into v. X delta S just means the sum of x values of the edges entering S and exiting S. So in any integral tour, for any subset of a vertex, you should enter once, at least once, and exit at least once. So that should be at least two. This is the standard alpha relaxation called the hardcore relaxation. You can solve it in polynomial time by either devising a separation oracle or writing an equivalent compact formulation. Okay, that's, that's well known. So I will write the hardcore relaxation here. And here I give you an instance to solve. Okay, let's find a good tour in this instance. So we have a linear program. Well, if we have a linear program, we usually solve it. So we solve the linear program. We obtain the, oh, so in this picture, this blue number is just the edge length, so the weights of the edges. So we solve the linear program, then we get the red, the black numbers, which is the number of times we traverse that edge. So this edge is traversed three times. This edge is traversed one time. This edge is traversed zero times, one time, one time. If we sum up the edge weights, it will be 22. Three times four plus one times one, plus one times one, plus one times two, and so on is equal to 22. You can see that in my, so okay, I have bad imagination. You can see that in the sense that it's an integral solutions, we were lucky, but that's not the point here. So I just, that's just because of my imagination. But we can also see that we have some zero edges. So Alpi basically tells us you shouldn't, under no circumstances, use these edges in your, in your solution. So let's just forget about these edges. If we forget about these edges, the linear program will have the same value because it didn't use these edges. And if we can find a tour in the subgraph, that would be a tour in our original graph. So we can just forget them and look at the smaller instance, and that's an equivalent instance. Okay, so we can forget about all the edges with zero value and we get a cleaner picture. Okay. And now all the edges remaining have a positive Alpi value. That will be important. So everybody that was remaining has a positive Alpi. Let me clean up the picture to replace, since I had such a bad imagination, so I selected a primal solution to be integral. Let me just replace that free by three copies, this two by two copies, and remove the ones to clean up the picture. Otherwise I have too many numbers. So this is the remaining edges in our Alpi solution or the support of our Alpi solution, if you so wish. Now we want to understand, do these edges have any special weight structure? So I gave a way to you that we should use Alpi duality. So what can we say about edges that had a strictly positive primal value? What kind of solution could we expect to have, what kind of structure could we expect them to have using Alpi duality? So if an edge has a positive edge value in the primal, so Xe is strictly positive, what would that mean for the dual, for a dual optimal solution? So you know, it's maybe you notice by complementarity slackness, every positive value in the primal corresponds to a tight constraint in the dual. Every positive value in the dual solution corresponds to a tight constraint in the primal. That's if and only if. So if you have an optimal primal and dual solution, any positive value in the primal corresponds to a tight constraint in the dual, every positive value in the dual corresponds to a tight constraint in the primal. So to understand if these edges have any structure, we will look into the dual. please interrupt me at any point okay so now we write down the dual it's impossible to understand so we will take it slowly okay so the dual will have a variable for each constraint in the primal so we have these constraints so the dual will have a alpha v for each of these constraints we call it the vertex potential for each vertex it will have a variable for each cut constraints which are variable ys for each cut this and then it will have a constraint for each variable in the primal so it will have a constraint for all uv in E okay and that constraint simply says that the sum of the y values of the cuts crossing that edge or cutting that edge plus the tail potential minus the head potential should be at most edge weight okay so let's do some examples because that's tough to think about yeah so here sorry so here I depict a dual optimal solution so the numbers on the vertices is the vertex potential so 6 is the alpha value for this vertex and the red sets are the cut value so ys for this set here is 1 ys for this set here is 2 ys for this set here is 4 ys for this set here is 4 all other cuts have y value 0 so this is a dual solution so we can just verify that the strong duality holds so we have an optimal dual solution so we have 1 plus 2 plus 4 plus 4 so that's 8 10 11 and the objective function is two times this sum so the dual value is two times 11 so it's also 22 so so luckily I didn't mess up so strong duality holds here okay so let's now verify the constraints of the dual so let's look at an edge here in the primal so it had a positive primal value so that edge we should verify this constraint so that edge crosses 1 tight set with a positive y value so this sum here sum of ys for this edge is 4 the tail potential is 3 so it's 4 plus 3 and the head potential is 6 so minus 6 so that's equal the edge weight 1 okay and we need that it's at most the edge weight this edge well he crosses two red sets 2 plus 1 his tail potential is 4 minus the head potential is 6 that's again equal to his edge weight this edge well he's crossing that tight set so it's 2 plus 2 minus 4 which is equal to 0 which was his edge weight finally this guy he's crossing no tight sets he has 0 there and then it's plus 6 minus 2 which is equal to 4 good so you could see that everybody ended up with equality and that's because I kept only the edges with a positive x value so now if I'm given an optimal primal solution and an optimal dual solution I know that every remaining edge corresponds to a tight dual constraint okay so that's complementary slackness for you so let's see what happens but complementary slackness every edge so we have a tight dual constraint for edge so now think about it so this alpha u and minus alpha v they are vertex potentials so what happened if I just normalize my weight function with uh with uh vertex potentials in the sense that I increase the weight if I well let me write it here so I replace the weight function w v by the weight function minus alpha u plus alpha v so I take minus the tail plus the head if I do that for every weight every edge what happens to Eulerian solutions you know Eulerian solutions have equal in degree and equal out degree so I get minus equally many times as I get plus okay so if I write this normalization as w prime where I normalize with the vertex potentials you know it can be any vertex potentials then for any Eulerian's edge set f I have that the old weight function the weight of that weight function is equal to the weight of the new weight function where I normalized it with the vertex potentials so yes to see that let's look at a small cycle that's an Eulerian graph we have that the weight w prime is the weight original weight of the ab plus oh I messed up the plot it's the same so plus alpha a minus alpha b weight of bc plus alpha b minus alpha c alpha b cancels out here weight of ca plus alpha c alpha c cancels out minus alpha a alpha a cancels out so yes because the in here is equal to out degree the vertex potentials cancels out okay you're with me with this so this is actually the intuition how I think the intuition how held car proposed to give a lower bound for tsp for the symmetric variant so what they did is to start with vertex potential zero everywhere find a minimum spanning tree that's a lower bound of a tour now update the vertex potential by increasing the vertical potential of high degree vertices resolve the minimum spanning tree problem okay and now they did that in a kind of much bigger weight update fashion I guess so as to get like vertex potentials that gets the best possible low bound and that coincides with this linear program because what I'm saying here that the dual is this vertex potentials plus this cut constraints okay that was a side remark so we have some vertex potentials that we can just incorporate and normalize our weight function so let's just do that in this example so we normalize with our vertex potential to get a new weight function and that weight function w prime is just notice that the edge weight of everybody is just the cut value that it crosses so the edge weight of this edge here is just one because it crosses one tight set in a dual with a value of one the the weight of this edge is two because it crosses this tight set in dual and this set in dual with value two the weight of this edge the weight of this edge is free because it crosses these guys two plus one so it's free okay so I just normalized using the vertex potential of the dual and now I have a weight function where every weight is equal to the y values of the set across so we can just forget about the weight vertex potentials okay so what happened we started with something complicated with no structure we dropped the zero edges we used complemented territy slackness we normalized with vertex potentials we got an optimal primal x and a dual y zero now because we already normalized with the vertex potentials so that the edge weight of every remaining edge is just the sum of the values of the cuts it crosses okay so that's the structure we have so that's pretty nice so every weight of every edge remaining is just the sum of the y values of the sets it crosses okay but we we agree this we want more structure we want to squeeze out the last bit of information we can get from alpiduality and and why can we get more information so we only use complementary to slackness in one direction right we used it on the primal saying that x values positive that means that the dual constraint is tight we also have it in the other direction so if we look at the support of the dual solution then by complementary slackness the corresponding constraint in primal should be tight that means that for everybody here every cut with a positive value there's one unit of flow going in in the alpid solution and one unit of flow going out okay so this means that the alpid tells us that each of these sets with a positive y value should be entered once and exited once in an optimal torr okay now the final structural result that we will use where I will not explain you everything is that by by now fairly standard and crossing techniques we can assume that l is a laminar family that means that there is no two sets intersect non-trivial so every any two sets in l are either disjoint like these two sets are disjoint or one is a subset of the other so this has been used for this kind of problems now for a while it was using you know yanes ground breaking works for iterative rounding for survival network design it was used in sing and laos launcings paper mean degree spanning crease and it was used for tsp not in iterative rounding but before to get structural results by connellus and others already in the 80s okay but that is to say that we can assume that these sets form a laminar family okay okay so yes to repeat what we can assume now is that we have a laminar weighted instance that's what we call laminar weighted we have x y to be primal and dual solutions the support of the dual solution is a laminar family nice to be drawn like this every set is this two sets of disjoint or one is a subset of the other and this defines the instance okay of course I didn't draw the edges so the weight function is implicitly yeah so this is a tight set so the in degree of this set is equal to one the out degree with respect to the lp solution x is one of course the weights are now implicitly defined by just saying the weight of every edge is equal to the value of the sets it crosses so the weight of this edge would be two plus five plus one which is eight the weight of this edge is one plus three plus two plus five and if you have the anti parallel edge then the weight would be the same so it's important that that the graph is not complete right so we we worked on a subgraph so in the subgraph that we worked in g then the weight of every edge is equal to the value it crosses and what I what I explained to you is that by lp duality we have that the raw approximation algorithm for laminar weighted instances just yields a raw approximation of a general at sp this is the weight functions you have to consider if you want to approximate with respect to the helicopter relaxation and for future notation I will just use the helicopter low bound to denote opt and that's two times the value of the sets the cut set so it's one plus three plus two plus one plus five plus two times two everything so it will be 28 the helicopter low bound in this example so it's two times the value of these cuts so if you're completely lost now is the fish okay so if you lost me there basically what you have to remember is that now we have reduced our task to this we are given a laminar set of cuts the weights on the cuts and the edge weights in the graph are just the sum of these weights that it crosses so that's what we call laminar weighted instances any any questions on this point so this was the first reduction using lp I think I like if you followed basically I explained everything except the uncrossing which this is pretty standard so that's that's the first reduction all right so so just just remember that oh there is a is there a question so I can hear some noise in my so I can type the question we can't hear you I think yeah it's I think it's best if they type the question maybe because we couldn't where can I see I cannot see well I mean they haven't typed anything I'm monitoring that but if they type something maybe you can go ahead and once they type something all right so let's remember that this is what we have to solve so now I will explain well the next step and we want to have more more structure to be able to solve a problem right so so this is what we call irreducible instances so this is a picture of some game and the point here is that there is a very long path from where you enter and exit this game board and and what we will see is that the irreducible instances are those instances in which they are very long paths from where you enter a set s tight set s in our laminar family and you exit okay and this I hope maybe this will make sense after I describe what it is and here the basic idea is simple so just you know if you want to have a recursive algorithm and still obtain a constant factor approximation algorithm that's fine if your recursive calls is on an instance with a smaller optimum value with a smaller smaller LP value so I will explain this idea in a simpler setting maybe in the cycle cover approach so maybe I will answer the question I got in the beginning of the talk how how one possibly could get a constant factor with a cycle cover approach and then we'll get back to our setting and see how to implement it there okay so now I let's take a detour so I made a word you know sorry for a bad joke with words it will come one more so you have to prepare yourselves okay so let's make a detour and consider the repeated very nice repeat cycle approach by Frisk Albiatti and Mafioli from 82 okay so remember their approach was based on forget about connectivity and let's always maintain no layering graph and build connectivity iteratively so the first step they find a cycle cover well cycle is a special case of a tour so the cycle is because of most opt but it doesn't connect the whole graph so now let's select the vertex inside each component like these green vertices here now that's a smaller instance so we can find a cost a cycle cover of course at most opt of that smaller instance which is at most opt of the whole instance so we have against the cost of the green cycle is at most opt and now we have two components we select two representative and we solve again so here in this example the total cost is at most three times opt so the cost here was three times because we did three iterations so in the worst case we all cycles will have length twos we need to repeat log base two n times so each time it's cost opt so there's two ways of improving this analysis one or at least two so one way is to say hey I cannot be this unlucky all the time to only find cycles of length two I should make more progress and thereby fewer iterations another way that we will pursue is to say the following weren't we a little bit pessimistic saying that every time we pay opt of the whole solution after all when we selected the first cycle cover we made some progress so we could hope that the second cycle cover on a smaller instance is cheaper and the the orange cycle is even cheaper and so on so this is what I mean that recursive arguments they are fine as long as you can prove that the value of your instances drop okay so suppose we run the cycle approach and now what happens if the value of opt would drop let's say by factor nine over 10 each time well then we don't have to worry about the number of iterations right because you will have this nice fast decreasing sum so nine over 10 to power of i where i is the number of iterations so if you sum this up even with infinitely many iterations you will have at most 10 times opt approximation so then you will be very happy and you can write your paper so we don't know how to implement such a strategy with a cycle approach we don't know how to select the cycle covers in each iteration so that to guarantee a drop in the LP value drop an opt so this is a natural approach that many have tried but nobody has succeeded but we will pursue this strategy now using the structure of laminar weighted instances okay are you with me so I can recursively solve my problems as long as the smaller instance have a smaller opt value okay so now the second lure tour that's the second second word play so this is the return in French all right sorry so so now okay remember we have this setting we have laminar weighted we have sets here the edge weight is just the sum of the values of those and and to implement the recursive approach we will need two two concepts that's what I call contraction on a lift okay so let's look at the contraction so this is a laminar weighted instance if I look at the set here set s maybe this set here remember that this was a tight set meaning that the LP value of the incoming edges they summed up to one so for example this was one fourth one fourth one fourth one fourth the total x value coming into this set is one similarly the total x value going out of the set was once maybe one third one third one third so I could simply contract that set to get a smaller laminar weighted instance so I replaced that whole set by single vertex okay so that's just a standard graph contraction so now the LP says hey you should visit this vertex exactly once okay so this is you know gx and the laminar family that's just a standard contraction but it remains to somehow what kind of y value should be set for this set here that replaced all these sets okay so that's the question mark that's the only thing we need to specify and we can contract any of the sets in our instance we could also contract this bigger set into a single vertex and now the question is again how do we specify this y value so that's what I mean by contraction to understand how we set this y value it's instructive to look at how do we use this contraction in our recursive algorithm okay well we have a smaller instance so let's just recursively find a tour in this instance okay like that that's a tour now we want to lift that so that's what I call a lift so I want to lift that tour back into maybe not a tour but a sub tour here so I just start okay I take the same edges in the same order so I take this I enter here ah but now I have to exit over here that's not that's not the same vertex so I have entered here I exited over here so that what can we do so I need this to patch this up in some way right my tour walk in this in the contracted instance I walked like that and now in the lift I started here I walk more walk I enter but now I have to exit there I want this to be on a Lyran instance and connected sub tour what can I do there's like what the simplest possible way to fix this okay I claim that the simplest but well just add a shortest path from the end from this vertex where we entered to the vertex where we want to exit so we just add a shortest path okay now we continue the tour we enter here and we exit there so we add a shortest path that's what we call a lift okay so again we will use the contraction to contract the big set in a lamina family into a single vertex we find the tour in that smaller instance that will lift back into a sub tour in the original instance I say a sub tour because although this thing here visits everything outside the contracted set it might not visit some guys inside the contracted set okay so it's not a tour it's a sub tour right because I just added the shortest paths so I cannot guarantee that I visit everything inside this set so now let's get back to how we set this question mark we want to set this question mark so that we are sure to pay for this rewiring inside a set so be sure to pay for these shortest paths so we set y value of new set to pay for maximum possible cost of all possible ways to enter and exit this set so in this example maybe the worst possible way was to enter here and exit here and the shortest path actually crosses every set so in that way you have to put the question mark to be the sum of these sets that crosses five plus two plus two plus one plus four plus three okay so that will be that you put the question mark to be 17 okay so let me just skip that and say so if we put this question mark to 17 let's say say why it pays for the lift okay so we found a tour in the contracted instance okay and then we lifted it back to to the original instance so clearly everything outside the contracted instance pays the same so we can in the in the difference in cost we can just forget about everything outside so now we have to worry about the cost of each visit to the contracted set so in the contracted tour right when I when I entered here and exit the deer I paid 17 to enter and 17 to exit so I paid two times 17 well actually yeah well I entered here and exit there I paid two times 17 now let's look at what do I pay when I entered here and exit the deer well I paid to enter I paid five plus two on this edge then the shortest path played two plus two times two plus two times no time plus four plus three the edges I crossed and then to exit I paid three plus four again so in to summarize I paid all the sets that I cross times two so I paid two times five plus two plus two plus four plus three minus what I paid over here maybe what I said was not so important exactly the five plus two and so on what is important is that by definition we selected this 17 to pay for any way we enter and exit so for sure this is at most zero and similarly this visit the second visit to the set was even cheaper but we again paid two times 17 in the contracted instance so the way I selected 17 was to make sure that the change of cost is at most zero so I have the fact that the lift here is not more expensive than the cost of the tour in the contracted instance that's the way how I set this weight here okay that's just the definition set the weight here so that you pay for the most possible way of and most expensive way of entering and exiting a set so I have a question actually can you hear me yeah I can hear you very well so is it obvious that this 17 is finite always yes I knew this question would come up so I should have prepared but yes no it's not obvious so so let me come back to this fact I skipped okay okay so first one can prove that there exists always a path from a vertex that you enter a tight set to a vertex you exit a tight set actually there exists always a path from a vertex that you enter to a tight set to every other vertex in that tight set the intuition why this should hold is the following the linear program tells you that you should enter this set exactly once but if you should enter this set exactly once well then you need to visit every other vertex before going out right so by the cut if you play around with the cut constraints this will be hold by linear program because the only way that you can enter a set once and exit a set once in an integral tour would be to have an Hamiltonian path inside so that's the intuition why we can always find this path inside from the entering to the exit and now similarly to a generalization of the fact that if you take a shortest path you can assume that it doesn't have any cycles right so you visit each vertex exactly once at most once you can generalize this fact tight set so you can say that the number of times we enter a tight set is at most once so this means that we will cross each tight set at most two times but that's exactly the value of the LP on this set so in fact not only that it's finite we can prove that the contraction never increases the LP value that that answers your question you have to do some sport yes it does things yeah so I mean yes so I can answer this question also we're drawing but that's that's intuition okay so that's a very good question it's not obvious at all and you have to think about it and the end zone but it turns out that you can always find paths so you cross each tight you enter each tight set at most once so the contraction never increases in cost so actually what I drew here was the worst possible case that the contraction has the same cost as the original instance okay so let me just summarize if everybody didn't follow everything here so let's just summarize what we need to know about contraction so fact contraction does not increase the LP value that's by Ilya's very good question lift no more expensive than Tor that's by the sign we set the value here to pay for this rewiring somewhat negative fact though is that the lift back to the original instance is not a Tor right it's a sub Tor because we are not necessarily visiting every vertex inside a tight set s it visits everything outside but not inside okay but now we will apply our recursive ID so if the contraction costs a significant increase in the value so if this smaller instance has a much smaller LP value then we can reduce the remaining budget we get to complete the Tor inside here okay so that's the implement in the recursive strategy and to formalize what we mean by decreasing the LP value in a contraction we we define what we say a reducible set so a tight set or a set in our lamina final L is reducible if the worst way to answer exit cross at most awaited three four fraction of the sets inside s okay so let's take an example so here is a set s the total value inside is two plus two one four three in this if this set so that's 12 so if this set should be reducible then the worst way to enter and exit you cross sets of value at most nine to be reducible so if we look at this case the worst way to enter and exit well it crosses all the tight sets of value so it has a it crosses sets of value 12 so that's an irreducible instance because to be reducible it should cross sets of value at most nine if we look at this case instead if this is the worst possible way of entering and exit this crosses the set two plus two plus one plus four which is nine so this is exact this is just reducible so why am i doing this because if this is the worst way of entering and exit i do the LP value will decrease because it's cheaper than what the LP tells me i have to pay in order to visit all these verses and we say that an instance is irreducible if no set L is reducible so that's the concept of irreducible instances and that's why i had this picture of the long paths okay so now maybe the main yeah the main thing we're going to prove here is that in this talk is that the raw approximation of irreducible instances actually yields a eight row approximation are for laminar weighted instances and therefore general AT SP so this means that if we can approximate irreducible instances then we are done and to prove this we will use the recursive approach so suppose someone gave you a row approximation are for irreducible instances and we will use this just give a eight row approximation for any instance any laminar weighted instance okay so given a laminar weighted instance if instance is already irreducible well simply run your algorithm to get a raw approximator that's better than i promised you i promised you an eight row approximator so life is great now if the instance is not irreducible what can we say well the instance is not irreducible because there are some reducible sets so now we select a minimal reducible set so this minimal will be important soon you will see why so s here is a minimal reducible set meaning that every set inside is irreducible now we contract it set so now it's 14 because it's and it was 17 when we had to pay for everything 14 so the LP value dropped now we find a tour here it's an eight row approximator okay so recursive call returns an eight row approximate solution t on smaller instance so it's just eight row opt minus something so if i write out the math it's two row minus something forget this is just some some remaining body yet because this has smaller value than here okay so we will see why why this makes sense soon okay what is important is that it's eight row opt minus something positive now we lift that back into a lift we know that the weight of this lift is at most the weight of the tour so everything we have to do is to complete the lift into a tour again using our argument a while paying at most this remaining budget that we got from the recursive call on the instance with a smaller optimal value okay so that's what we have to do to finish the proof complete to tour while paying at most two row times this two times the sum of y values inside a set s okay remember that the lift visited everything outside s so we only have to connect unvisited vertices inside s like this one and that one i will explain this with a simplifying assumption so suppose we had that the following so instance obtained by only looking at the inside of set s is itself a feasible instance so somehow the health care solution is also feasible inside this set s by just removing everything edge going out and in this is a simplifying assumption that is not true in general okay but let's just assume that this is true what can we say about this instance that we get by inducing on the set s it's an irreducible instance since s was selected by a minimal reducible set right if it's every set here has to be irreducible because otherwise we would have selected this before the LP value is two times the the the sets inside s so it's two times two plus two plus one plus four plus three that's exactly what we had here in the save by the basically we define it so that it's exactly the same but these two times here is exactly the same thing as these two times so now we have an irreducible instance with small LP value we can use our algorithm a to find a raw approximate solution there so this is better than what we needed we needed two raw and we found a raw approximation for that and that that's our green solution so it's a better than a factitude than you need so let me just repeat what we did okay so we're given an instance we select a minimal reducible set we contract and recursively find lift that's a odd eight raw approximation we have some remaining bad yet because the contracted instance dropped in value then under simplifying assumption we found using a a tour inside that set of value at most raw times the LP value of the solution inside that set summing that up we got a tour of value at most a to opt minus raw times two times level okay so that's that's great of course the reason that they have this slack in my proof is because our simplifying assumption is not true in general so in the paper we define a more complicated operation to induce on the set s that makes us lose another factor of twos you will get that two times here and that you will get a tour here but here the key idea is we can contract if we get an instance of smaller value we can use the remaining bad yet to complete the tour inside us okay so now if you if you got lost the goldfish is back and what you should remember is that now we can concentrate on a reducible instance so we have so we have reduced all problem of approximating at sp to uh to that of uh uh approximating irreducible instances any questions on this that it went a little bit quick but uh hopefully yeah that's an idea all right so let me now explain why intuitive yes so actually is there some intuition for the factor three four you've got in the definition of reusable like why is that I see you select anything uh I think like close you I think maybe more intuitively 99 percent then you will get if you select like reducible if you dropped out the value with one percent here we say like we should drop one fourth of whatever is inside but you know then you will get hundred instead of eight so yeah basically as long as we can make sure that out value drops with a constant what is inside the set s then we're fine so you can select one fourth you can select one over hundred one over thousand it turns out that three fourth is close to what gets the best ratio okay but you know if you select 99 percent here it's pretty good because that means that irreducible means that the path is very very long so so this uh this this uh means that in the lift you would intuitively revisit a lot of vertices so that might be better for intuition then three fourth is just a number it's I don't know of any deep reason so so let me now just quickly explain why intuitive we are done and that's the vertebrate pairs so and here the basic idea is the following okay so now we only have to consider a reducible instances but if you think about it they're almost not weighted instances so let me explain what I mean and that then the then the question I that was just posed will make even more sense okay I mean it made perfect sense just before but it will be very timely now okay so because not only I will assume 99 percent that the path crosses 99 percent here I will assume that it crosses everything so suppose you have an instance that is perfectly reducible meaning that the contraction of any set causes no decrease in the LP value furthermore supposed that the laminar family contains all the singleton so every vertex has a node weight okay then when the contracting a set the LP decreases proportional to the number of sets not crossed by the worst way to enter and exit okay so basically since we assume that we are perfectly reducible the worst way to enter and exit must visit all the vertices because otherwise the contraction would lead to a decrease in the LP value so now I think if you think about your question right now it makes perfect sense so suppose I would define instead of using three fourth I would use like 99 percent 0.999 percent that means that even in the quantitative approach I will visit 99.999 percent of the vertices now I do like a qualitative statement to simplify things I say we are perfectly reducible there is no dropping value at all that means that we will actually there exists a way of entering and exit so that the shortest path visits everything okay so now in this perfectly reducible world well what we can do is just to contract all the maximal sets in our laminar family okay so now we just have single vertices and the laminar family only contains the singletons this is what we call the node weighted case because the weight of an edge is just the node weights the sum of the node weights okay so this is a node weighted instance we have a 28 approximation just find the 28 approximation tor and now we lift it back to a tor in the original instance with one tweak okay so here I enter this set then I exit this set here in the left right we added the shortest path between these two vertices now I will do is to first add a shortest path to the worst way to enter then the shortest path from the worst way to enter to the worst way to exit followed by shortest path from the worst way to exit to the to the way we wanted to exit I do the same thing here I add a shortest path to the worst way to enter a shortest path to the worst way to exit finally a shortest path to worst way to enter I only do that the first time I visit the set so here I don't need to do it so just continue now in this set here I do the same thing so I add a shortest path to the worst way to enter for this path to the the worst way to exit, followed by a short path from the worst way to exit to the way I exit. So this is the way I build my tour. So again, it's not maybe clear for you that all these short paths exist, but they do exist. So we got a tour, because we assume it to be perfectly reusable. What's the cost of a tour? It's the weight of the lift plus the weight of all these paths that I added. So the weight of the lift was just 28 times opt, because we use a 28 approximation for the node weighted case. Now we have to worry about the weight of the paths. So we added three paths inside each set. One can prove that each of these paths only crosses each enters each tight set of most ones, meaning that each path has value at most LP value inside this set. So we have three times the value of this set inside this set plus three times the LP value inside this set plus three times the LP value inside this set. So in total, the total cost of the path will be three times opt. So the total cost will be 31 times opt. So this is the intuition why irreducible are very helpful. In particular, if we had a perfectly reducible, meaning that no contraction drops the LP value plus the node weights, that means that there exists a way to enter and exit so that the shortest path visits everything. And this is very helpful because then we can just rewire the tour in the contracted instance into a tour in the completed instance. So of course, in general, you don't have this perfectly reducibility. So instead of finding a tour, you will find what we call a backbone that intuitively visits almost everything. In particular, it crosses all the non-singleton sets in our laminar family. And using this, yeah, we call bees called the backbone and together instance, they form a vertebrate pier. Then we complete this using a connection to local connectivity, and constellations. So I decided to focus on the reductions. But this part, Laszlo talks a little bit in a recorded talk that he gave at Simon's Institute. So I think I can refer you to that talk or talk to me or Jakob or Laszlo person or to me later about that. So I decided to explain to you why reducibility is very helpful. Perfect reducibility actually gives you a tour. And intuitively, you get a backbone that visits 99% of the staff. Now you have to complete it, you can do it. So summary and open questions. So we get this constant approximation with respect to a carp relaxation. It's based on a sequence of reductions that add more and more structure. We arrive to the reducible instance and vertebrate pier. Intuitive, we almost solved the problem here. So I hope I gave you the appetite that either you can try to complete solve this yourself, maybe you do it in a more beautiful way. Or I gave you the appetite to look in the paper how we do it. So we also have a 10 page summary on our home pages that gives an overview of these reductions. So these are highly modular. So you can read this one day, the other day, the third day and fourth day and so on. So that's an advantage. But it also makes you lose a constant. You lose a constant 8, 4, here you lose 29 or 30. So if you want to get close to 2, you cannot lose a constant in each reduction. So the way to get down to a couple of hundreds even is to lose this very modular structure and highly specialize the different parts to the framework. So this is a pretty big price to pay if we can only get down to a couple of hundreds. And that's why we didn't do it. So that would be a much more complicated paper, I think. But even if you would specialize things, we don't know how to get close to 2, close to 10, even close to 50 would be very interesting. So here the technique we used in the first reduction was this amazing power of output duality. Here we used the recursive approach as fine as long as op drops. Here we use that the reducible instance actually behaves as node weight as we can use the constant factor approximation algorithm for that case to get a torque, almost a torque. That almost a torque we call a backbone. And together with the instance, we call it the vertebrate pair that we complete using the connection to local connectivity and circulations that I didn't cover. So I think some of the hot open questions is the right ratio too. As I explained, you need new IDs, definitely. One very nice question is bottom like ATSB. So here you're given a graph, a complete graph with edge weights that satisfy the triangle inequality. Now you want to find a Hamiltonian cycle that minimized the max weight edge. So I think this is a nice question itself. There is a tight answer for the symmetric case, which is 2, that has been known for several decades. But still there is only a super constant algorithm for ATSB, bottom like ATSB. And the lower bound I think is only 2. And so this is an interesting question itself. And it's also motivated by, I would say, the fin tree conjecture, which remains a very interesting question. So is there a tree, well, T such that for every cut, the number of edges that crosses that cut is proportional to what the LP value tells you. That's the question. And it's known that the fin tree conjecture, if true, would imply a constant factor approximation for bottom like ATSB. So this could be seen as a slightly easier problem than fin tree conjecture. Or in the counter positive view, if you could prove that the bottom like ATSB has no constant factor, then that would show that there is no constant fin tree. And one of the questions we are interested is also no way to symmetric TSP. So somehow here, no way to ATSB was important for no way to symmetric TSP. Nothing is known, but the bank is to feed us. Okay. So thank you. Thank you. Thank you. Do we have any questions? So do you, is it like, is this possible to give any hint on how the local connectivity thing works? So yeah, of course, yes. So let me try it. So let me see here. I had set something at the try this just quickly. Okay. So, so yes, explain you what the problem is. Okay. So, so in ATSB, right, you want to find a tour. Can you see this? Yes. Well, actually, it doesn't work because, oh, okay. I don't think it works. That's okay. No way about it. So, oh, now it works. Sorry, sorry. So in ATSB, right, you have a graph with a bunch of nodes, and you want to find a tour that connects all of them. In local connectivity ATSB, you are given a partition of the vertices. Okay. Okay. And now I only ask you to find a collection of subtours so that each partition is crossed at least once. So you can have a red subtour that crosses these two partitions. You could have a blue subtour that crosses these partitions. You don't need to connect the whole tour, but you need to cross these subpartitions. Now the objective function says that each of these subtours have to locally be good. So that's a little bit complicated to define. But we knew how to solve this in a node weighted case. Okay. And now we have reduced our case to this vertebrate pier where we have a backbone that almost visits everything. Okay. So now what we can do is that this behaves like the node weighted case. If we can connect these vertices to this vertex, then we are part of the backbone. Connect this vertex to that vertex and so on. So inside, if we don't cross any non-singleton tight sets, the objective function behaves like the node weighted. So basically we connect everything as long as we can in a node weighted approach and then we pay one time up to connect it to the backbone. But yes, that was not a crystal clear explanation. But basically when we have this backbone, we have almost a node weighted case. But I'm not able to explain it that way. Thank you. No, that was good. So you're saying that if it was completely, forget the name you used, if it was actually the node weighted, though it was exact backbone, then it would be, you would be, and okay, so there's a similar version of. So if it was perfectly reduceable, we actually found a backbone that visits every vertex. So then we are done. Okay. So then there is nothing to do. So you should think of it, right? We find a backbone that visits 99% of everything. That's great. Any other questions? Okay. If there are no other questions, we'll take this offline. So a couple of things. So again, a reminder that the, a week from now we have a Vino Vecondaton speaking on cryptography. So that's a week from now, not two weeks. So we hope, I hope you join us then and also today there was supposed to be 15, an audience of 15. So we had about 20 YouTube viewers and five of them were supposed to be on the hangout, but that would be my mistake. So I'll get fired from this job. So anyway, thank you for joining us. I'll take it offline, but you're welcome to stay.