 Welcome everyone. This week's edition of TCS Plus. We've saved the best for last. We have Julia Chujoy speaking today. Julia is an expert in combinatorial optimization, approximation algorithms, and hardness of approximation. Before I tell you more about Julia, let me quickly go around the table just to introduce the groups. So we have Clemore Canons joining us from Stanford. Hello, Clemore. We have Irfan joining from India. Irfan, thanks for joining. We have Max Hopkins from UCSD. We have Shavasrao from NYU, a few floors above me. We have Ziyan Tan from University of Chicago. And I think it's Thomas, is it Thomas Videk? You're graying it today. I'm not sure. It might be Thomas Videk from Kotec. And, oh yeah, it is. And we have the group from Toronto, then by Kiksa. And I think we have one more group, Yijun from University of Michigan. Okay, hello and welcome everyone. I also should thank my co-organizers, Gautam Kamat, Clemore Canon, Thomas Videk, and India Day. Before going on, let me quickly introduce our speaker today. So Julia graduated in 2004 from the Technion under the supervision of Sethi Naor. She did post-docs, MIT, and University of Pennsylvania, UPAN, and Institute for Atlanta Study. She's currently a full professor at the Teota Technological Institute at Chicago and also part-time with the University of Chicago. She has a base paper award at Fox 2012, as well as a Sloan Research Fellowship and an NSF Career Award. And I think today she'll be telling us about the paper from stock 2018, named almost polynomial hardness for notes in joint path in grades. So welcome Julia. Yeah, thanks Aded. So thanks everybody for joining and thanks to the organizers for inviting me. I'm actually speaking right now from Israel where I'm doing my sabbatical. So it's pretty late in the evening here. So I'm going to talk about almost polynomial hardness for notes in path in grades. Yeah, so I don't know how it goes. If you don't hear well, maybe interrupt me. So this is joint work with David Kim and Rachid Nima, but both of them are students. David just graduated. So this is the problem I'll be talking about today. It's called no-digene path or NDP. So we have a graph, undirected graph. We have pairs of its vertices, S1, T1, S2, T2 through SKTK. We call them demand pairs. These are pairs of vertices that want to talk to each other, which we want to route. Now, what does it mean to route a pair? We need to find a path connecting this demand pair. For example, this red path here routes the S1, T1 demand pair. And this green path routes S3, T3 demand pair. But the path that I'm choosing for routing, they have to be disjoint in their edges and their vertices. So if I wanted to route another pair, I could not because they have to be disjoint. So I routed two demand pairs, and this means the solution value is two, which I want to be as big as possible. So what do we know about this problem? So remember, K is the number of the demand pairs. When we think of K as a constant, then there is efficient algorithm for solving this problem based on the Robertson and Simu's graph-minor series. They improve the running time of the algorithm looks like something like this. So f of K is a really large function of K. We actually don't know what it is. But in general, when K can be part of the problem input, the problem is NP-hard. So if K is like log N, square root N, and so on, the problem is NP-hard. So the next natural thing to ask is what about approximation algorithms for this problem? So let me show you the best and pretty much the only approximation algorithm we have for this problem. It's a really simple greedy algorithm where I'm going to iterate. In every duration, I'll take a path of minimum length that connects any demand pair, add this path to the solution, and delete all vertices that land this path from the graph, and repeat, and keep going like this. So a simple greedy algorithm just route and show this path every time. And it's not hard to show, although I won't go into this, that this gives you a square root N approximation. And until recently, even if your graph is planar, and even if your graph is a grid, we didn't have better approximation. So because I'll be talking a lot about no-diging path in grids, let me just show you what this problem looks like. So you just have root N by root N grid. And the sources and destinations listed anywhere in this grid. And so we want to route these demand pairs. For example, this can be a possible routing. Maybe you're going to say it, but is it easy to see why this is tight in grids? Say it again? Is it easy to see an example where it's tight in grids? Where it's what? The square root N is a tight bound. For this algorithm, yes. Actually, I'll need to think about this. Actually, I'm not sure. It should be. So this is where things stood around 2015. So we only had a square root N approximation algorithm, and nothing better, even for planar graphs and even for grids. And on the negative side, there was roughly square root log N harness approximation and nothing for planar graphs, nothing for grids. So at this point, it was kind of clear what should be the plan, and this is the plan that I had. I wanted first to get a polylog N approximation for this problem on grid graphs. I was very confident that this should be possible because grid graphs are so simple, and I actually don't know of any problem that's hard to approximate on grid graphs. And I was then hoping to extend it to planar graphs because there is a strong intuition that the most difficult case for planar graphs is grids. And after that, I wanted to look into general graphs, and here I was not sure what's going to happen. So with this plan in mind, we started working on approximation algorithms, and at the beginning, things really went according to the plan. We got a little bit better algorithm for grids, and a little bit better algorithm for planar graphs. This is a little improvement so that don't go into them, and also some special case of grids. But then things stopped going according to the plan. So first, we got 2 to the square root log N hardness approximation for sub-graphs of grids. So grids was holes where all sources sit on the boundary of the grid. And lastly, the result I'm going to talk about today is almost polynomial hardness for grid graphs. So specifically, what I mean by that, it actually depends which complexity assumption you're willing to assume. So you can get this 2 to the log to the 1 minus epsilon hardness approximation using this pretty standard complexity assumption that in human language means that unless every problem in NP has randomized quasi polynomial time algorithms, if you're willing to assume something a little bit weaker than randomized ETH, then you get n to the 1 over log log N squared hardness, and you can get things in between. So this is the formal statement of these 2 complexity assumptions. So this is what I'll be talking about today. But before I go into the proof, I want to just mention a few other related problems so that you get a whole picture. And the first natural question is edgy gene paths. It's really like a sister problem of no-digene paths. It's exactly the same, but now the routing should be on paths that are disjoint in edges, and they may share vertices. And it pretty much behaves like no-digene paths, the same up or the same lower bounds. But on grids, it's easy to solve. You get a constant approximation. However, if you look at this graph, it's called the wall graph. Then edgy gene path involves behaves like no-digene path in grids. And in fact, all the results that we have for no-digene path in grids carry over to edgy gene path in walls, including the result I'll be talking about today. And lastly, you may wonder what happens if we allow a little bit of congestion. So we allow paths to share edges or vertices to some limited extent. So this has been studied a lot. There's a really long history starting from the random adjoining technique of Ragovan and Thompson. So what we know today is that if you allow up to two paths to share a vertex or an edge, you can get a polylocale approximation, which means that routing with no congestion is dramatically different from routing with just congestion too. So from now on, I'm going to talk about no-digene path in grid graphs, the hardness approximation result. And so my goal, I will not try to show you the technical details in the math. I want to convey the main conceptual ideas. So we'll start with the first main conceptual idea. And I'm going to define an intermediate problem. It's a graph partitioning problem. So in this talk, I'm going to call it a weird graph partitioning problem, or WGP. It is weird. So in the paper, it has a more formal name, but I'll stick with this one. So I'm going then to show that no-digene path is at least as hard as this partitioning problem. And then I'll prove the hardness of this partitioning problem. In fact, it's going to be a little bit different. It's not exactly this plan. But for now, let's stick with this plan. So let me now go to this graph partitioning problem. And before I define it, I want to mention the kind of motivation why we did it. So we were actually trying to solve no-digene path in grids, try to come up with an algorithm, because it looked like an easy problem. And we were looking at some special case, and we worked and worked and worked. And we realized that what we are trying to solve is actually this graph partitioning problem. And when you look at this graph partitioning problem, it actually looks hard, unlike the no-digene path in grids. It looks easy. And this was our first idea that the problem may be difficult, and that this partitioning problem maybe is the key to look at. Yeah, I'm kind of, is everybody there? We are here. Okay, okay. I just think kind of look frozen on my screen. Okay. It's just a little weird. Okay. So let me now define this problem. So the input is a bipartite graph and two parameters P and L. So this is the bipartite graph. And what I want to do is I want to break it into P pieces. Every piece is a vertex-induced sub-graph. So I want to partition it into P vertex-induced sub-graphs. I'm going to call them pieces throughout this talk because there's going to be other clusters that they want to, I don't want to confuse between them. So what's the intuition? So intuitively, I want to make sure that as many edges as possible stay inside the pieces. But then we can get a solution where every edge belongs to one piece, like the whole graph sits in one piece and nothing else sits in the other pieces. And that's not what I want. So to get around this, I use this parameter L. And I'm saying that I will count the first L edges from every piece, everything else I'm going to ignore. So L is the limit on how many edges per piece you're allowed. So in other words, once you broke your graph into pieces, you have to delete edges from every piece. For example, these red edges are going to be deleted so that in every piece at most L edges stay. And then you want to maximize the total number of edges that remain in the pieces. And that's the weird graph partitioning problem. So in the next few slides, I want to relate this problem to some other problems that you are maybe more familiar with to give you a kind of intuitive feel of this problem. Just to make sure I understand, is it the same as taking the sum over the minimum between EI and L? What's the point of taking a subset? Maybe I'm missing something. Yeah, no, no, it's the same. You just count the first L edges. Yeah, it's the minimum between exactly. Yeah, there is no point. So I don't have to think of EI. No, it's maybe more convenient. So when you do the reduction to the origin path, it maybe helps you to delete those extra edges. So you don't count them. But otherwise, yeah, it's the same. Yeah, so now I want to connect it to some other problems. And the first problem is balance cut. And this is really how I think about this problem. So the difference is that in the balance cut, you want to partition into two pieces. And here you have P pieces. And the second difference is that in balance cut, you want to minimize the number of edges that get cut. And here we want to maximize the number of surviving edges. But otherwise, this L, this limit on how many edges per piece I'm allowed, so I can use it to enforce the fact that it's going to be a balance partition. And in fact, this is how I'm going to use it. And the second connection is to another problem called densest case subgraph. And it's this connection that made us think that this is a difficult problem. So to remind you, in densest case subgraph, you have a graph G, you have an integer K, you want to choose a subgraph of G on K vertices, and you want to maximize the number of edges that stay inside the subgraph. And this is a very notoriously difficult problem. So it has only polynomial approximation, algorithm with a polynomial approximation factor. But it was incredibly difficult to prove any hardness approximation for it. In fact, even APX hardness is a very difficult proof. And only recently, there was this breakthrough result of Manoranxi that proved almost polynomial hardness for this problem using ETH. So why I think about this problem like densest case subgraph? Well, intuitively, I want to break my graph into many dense pieces and not one. And maybe that's not very convincing. But when you try to prove hardness of this problem, you kind of run into the same issues as you do with densest case subgraph. Okay, so this is the problem we'll focus on. And now the plan has now two parts. We want to prove that nodige and path and grits is at least as hard as this partitioning problem. And then they want to prove hardness of this graph partitioning problem. Again, I'm going to tweak this plan a little bit later. But for now, that's the plan. And let's start with the first part, nodige and path is at least as hard as this graph partitioning problem. So I'm taking an instance of this graph partitioning problem. I'm going to put it on the side like this. And now I want to reduce it to nodige and path and grits. So I'm just going to put a really big grid here. That's my graph. And now I need to put the demand pairs. So what I'm going to do is that every edge of G will become a demand pair. And the endpoints of these demand pairs, they have to be disjoint because I need to route on disjoint paths. So yeah, so that's how we need to define it. So now I just need to tell you, well, where I put the sources and the destinations. So I'm going to choose two rows, one where the sources will sit, one the destination will sit. They have to be far from each other and far from the grid boundary. And now for every vertex of this graph G, I'm going to choose a contiguous area in the source row or the destination row that's going to kind of simulate this vertex. I'm going to call it a block. So here you have this block is the green vertex, this block is the red vertex and so on. And these blocks, they have to be far from each other and far from the grid boundary. And now we're ready to define the demand pairs. And that's just the natural thing. We just go edge by edge. For example, I take this red edge. I'm going to put a source destination pair like this. This red edge, source destination pair like this and so on. This finishes all edges that are incident to the green vertex. There is like little subtle point here, how we define the distances here between the sources. And we need to choose them carefully. So if the distances are too long, then you can actually route everything. So there are known results that show that in a grid, if the sources are far from each other, then you can route all demand pairs. But if the distances are too short, then there are some things that we need to route in our reduction and maybe we will not be able to route. So we need to choose them just right. And I don't want to show you the numbers. That's the intuition. So this is the reduction. Every edge becomes a source destination pair. And the claim is that this reduction preserves the solution value up to polylogan factors. If this is true, then no-digent pass and grid is at least as hard as this graph partitioning problem up to polylogan factors. Because whenever we have an algorithm for no-digent pass, we can use this algorithm to solve the partitioning problem. So let me show you why. In fact, I'm going to show you mostly one direction. So let's assume that I can route many of the demand pairs. And now I want to show you that there is a good solution for this partitioning problem. So maybe this is the routing. So first of all, I'm going to take edges in this graph G that I didn't route. And I'm just going to throw them out. For example, this red edge was not routed. I'm going to delete it. And so I get a large subgraph for my original graph. And next, I want to show that this large graph, it can be drawn in the plane with very few crossings. And I'm going to show it using this routing. So let me first show you how and then we'll see why this is useful for us. So how I'm going to draw, it's just really natural here. I can just take every block and contract it and get a drawing of this graph. But you have to be careful. So for example, if I take this green block, I'm going to choose one of these two vertices to serve as the green vertex, for instance, this vertex. And then I need to contract the other vertex into it. So I'll do it by extending this edge and I introduce the crossing. And I'm just going to go and do it for every one of the blocks like this. And in the end, I'll get some drawing of this graph G prime. So the claim is that this drawing has very few crossings. So why very few crossings? Because when do we introduce crossing? I introduce a crossing like when we did this here in this green block, when there is some path going through a block. But because the sources that we choose, they're relatively close to each other, it's not going to happen so much, you will not get so many paths that can go through blocks. And so relatively, I'm not saying it's very small number, but relatively it's going to be a small number of crossings. So what we did so far, we took a large subgraph of this graph partitioning problem, and I found a drawing of it with few crossings. How does it help me? So as you probably know, if you take a planar graph, a planar graph has very small balance cut. And the graph that you can do with few crossings behaves very much like a planar graph. It also has very small balance cuts. So by repeatedly computing balance cuts in this graph, I can break it into pieces and get a good solution. And I will lose very few edges. So that's how we prove one direction for the other direction. I'm just going to say very high level idea. So here we assume that we have a good solution for the graph partitioning problem. Maybe this is the solution. So the intuition is that this solution breaks the routing problem into small pieces. And these small pieces, we can route them independently. They don't influence each other because the distances between the blocks are really big. But the pieces are so small that they're small relatively to the distances between the sources and the destinations. And this is why I can route the pairs in each piece. So this is very high level. I don't want to go into this one because it's technical and I want to focus on the second part, which I think is more interesting. So in the second part, I want to prove hardness of this weird graph partitioning problem. Okay. So my starting point is a tiny bit unusual. I'm going to start with three coloring problem, three coloring five. So in this problem, I have a five regular graph that may look like this. And the three coloring of this graph, as usual, is an assignment of one or three colors, red, blue, or green to each one of its vertices, for example, like this. And now we say that an edge is happy if both endpoints have different colors, like this edge is happy. And otherwise, it's unhappy like this edge. So now given this five regular graph G, I'm going to say it's a yes instance if there is a coloring where every edge is happy. And I'm going to say it's a no instance if in every coloring there is some significant fraction of the edges that are not happy, let's say 1%. And from PCP theorem, we know it's hard to tell whichever it is. So far, this is standard stuff. But the reason that we start from three coloring and not something else is that we can get an extra property that's going to be really useful for us. What is this extra property? So assume that we are in the yes instance case, and we have this perfect coloring where every edge is happy. And now we have three colors. So there are six possible permutations of these colors. So I can take this coloring and apply each one of the six permutations to this coloring, and I'll get six different colorings, all of them legal colorings. And if I take any edge of this graph, for example, this edge, every edge has exactly six legal colorings, colorings where both endpoints get different colors. And each one of these colorings will appear in each one of these solutions. So every solution has a different legal coloring of this edge. And this happens for all edges. And now if I take any vertex, vertex has three possible colors, then every color will appear in exactly two of these solutions. So this useful property will be helpful for us. We call it the bonus property of three coloring, and we are not the first ones to realize this and use this in our reduction. Actually, the idea was stolen from this paper of Phi Get All. So let me now tell you what are the next steps. So I'm starting from three coloring problem instance, and I'm going to reduce it to an instance of constraint satisfaction problem. And this is going to be really standard step. It uses standard to prove a protocol and parallel repetition. And then from the constraint satisfaction problem, we get to the graph partition problem instance. So let me now describe the first step. And because it's really standard, I'm just going to show you kind of the end result. I'm not going to go through the two protocol and the parallel repetition. So now I'm starting with this three coloring five instance, this graph. And on top of this, I have R, which is the number of repetitions. So if you're not familiar with this, it's basically a parameter that I am free to choose. For example, I'll probably choose it to be like polylog N. So the bigger this parameter, the bigger the hardness gap I'm going to get, but also the size of this constraint satisfaction problem is going to grow with R. So I want to be careful about it. But now given this graph and given R, I'm going to build an instance of constraint satisfaction problem. So I need to define variables and constraints. And there's going to be two kind of variables, variables on the left kind of represent the edges of my graph variables on the right kind of represent the vertices specifically. So every vertex on the left is associated with a sequence of our edges of my graph. And in fact, every sequence of our edges in my graph is going to have a variable. And I'm allowing repetition. So it's possible the same edge appears twice in the sequence. And so because of this, the number of these variables is M to the R, where M is the number of edges in this graph. Now what's an assignment to this variable? An assignment is simply a legal coloring of these R edges. So every edge has to be colored so that the endpoints get different colors. And I don't care about consistency across different coordinates, different edges. For example, it's possible that these two are the same vertex and they get different colors and that's fine. And it's possible that these two are the same edge and they get different colors and that's fine. So these are variables on the left. And so we have exactly six to the R possible assignments per variable because there are six colorings per edge and there are edges. So now what about variables on the right? It's the same thing only with vertices. So for every sequence of our vertices, there's going to be a variable there. And again, we allow repetitions. And the assignment to this variable is again a three coloring of these vertices like this. And again, we don't check consistency across different coordinates. It's possible that these two vertices are the same and get different colors. And so the number of possible assignments for every variable on the right is exactly the same as three to the R. So these are the variables and now I need to define the constraints. So I take this pair of variables. I need to decide if I'm putting a constraint between them or not. So the rule is that for every I, VI has to be an endpoint of EI. And that's how I decide if I put a constraint or not. So V1 has to be an endpoint of E1. So maybe it's this vertex. I don't know what's happening with the mouse. Okay. And V2 has to be endpoint of E2 and so on. So if each one of them holds, I'm going to put a constraint. And one is the constraint satisfied. So here are assignments for these two variables. So what needs to happen is that for every I, VI has exactly the same color on the right and on the left. So V1 is blue here and blue here. V2 is green here and green here and so on. Again, I don't check consistency across different coordinates. So it's possible that V1 is also this red vertex here. I really don't care. Okay. So this is the CSP instance that's based on our graph. What are its properties? So if G is a yes instance, if it's three colorable, then there is a solution to the CSP instance satisfying all constraints, I'm going to call it a perfect solution. And if it's a no instance, if you cannot make many edges happy, then any solution will satisfy only a tiny fraction of the constraints. And this tiny fraction is 1 over 2 to the omega of r, where r is the number of repetitions. And we know it's NP-hard to distinguish between the two. So again, so far, this is really standard stuff. But now we get this bonus property because we started from three colorings. So let me tell you what is this bonus property. So if the graph G is a yes instance, we said the constraint satisfaction problem has a perfect solution. But in fact, it's going to have not one perfect solution. It's going to have six to the r perfect solutions that have some useful properties. And namely, if I look at the variable on the left, remember assignment to this variable is a coloring of these edges. So there are six to the r possible assignments. Let me write them here like this. Every assignment is going to appear in exactly one solution. And this will happen for every variable on the left. And if I take a variable on the right, so it has three to the r possible assignments, the colorings of these vertices, every assignment is going to appear in exactly two to the r of these solutions. And the reason we get this extra bonus property is because of this property of three coloring that we had that you can take any solution, you can take the six permutations of the colors and get six solutions. So we actually apply these permutations to each one of the coordinates. And that's how we get it. So this finishes this part. What I want to do now, I want to forget about this. And I'm going to pretend that I start from the CSP instance and get a reduction to the graph partitioning problem instance. So to do this, I'm just going to very quickly summarize again, what is the CSP instance so that we can have a clean starting point. So this is my CSP instance. And now I'm going just to say that it's a yes instance if there is an assignment to the variable satisfying all constraints. I'm going to say it's a no instance if any assignment to the variable satisfies only this tiny fraction of constraints. And I know it's hard to distinguish between the two. And on top of this, I have the bonus property, which is the following. If we are in the yes instance case, we have six to the r perfect solutions that satisfy all constraints, such that for every variable on the left, each of its assignments appears in exactly one solution. For every variable on the right, each of its assignment appears in exactly two to the r solutions. So this gives us the starting point. And now I want to show the second part of the reduction, which is more interesting how we go from constraint satisfaction to the graph partition problem. So I'm going to build two graphs for this constraint satisfaction problem. And the first graph is what we saw, the constraint graph. So there is a vertex for every variable, there is an edge for every constraint, it's standard. The second graph is going to be called assignment graph. And it is this graph that will be the input to the graph partitioning problem. So now for every variable, I'm going to put for every variable on the left, I'm going to put the vertex for each one of its assignments. So it has six to the r assignments, there's going to be six to the r vertices, each of them represents a different assignment to this vertex, to this variable. Now if I took a take a variable on the right, I would like to do the same thing, but I'm actually going to do something a tiny bit different. So for every assignment to this variable, I'm going to put two to the r vertices representing this assignment. So we have three to the r possible assignments to do the r copies of each assignment. So six to the r vertices again, same thing. And I'm going to go and do this for each one of my variables. So these clusters of vertices representing the same variable, I'm going to call them clouds again to distinguish them from other different kinds of clusters that we have. So every variable gets a cloud. And now I need to define the edges. So let's assume that there is a constraint between these two variables. So now I need to define edges between these two clouds. And the rule is going to be the natural rule. I'm going to put an edge here if and only if these two assignments satisfy that constraint. So maybe if I take all edges that correspond to that constraint, I'll get a bunch of edges like that. And maybe this is my whole assignment graph. So this is really almost like the standard assignment graph. The only difference is that for variables on the right, I'm going to put several copies of every assignment to make this even. Okay, so this is the assignment graph. And now I'm going to use this assignment graph as an input to the graph partition problem. And again, remember that every cloud has exactly the same number of vertices, six to the r. So I want to break this graph, this assignment graph into exactly six to the r pieces. And the limit, how many edges per piece I'm going to be allowed to count is at most is exactly the number of constraints that we had. So to make this maybe clearer, let's look what happens in the yes instance, because I think this will make things clear. So in the yes instance, we said we have not one perfect solution, we have six to the r perfect solutions. And every cloud, it will have exactly one assignment in each one of these solutions. So because of this, these solutions, they basically partition my vertices, I can break my graph into six to the r pieces using the six to the r solutions. For example, if I take the first solution, I want to define the piece corresponding to it. So for every variable, I'm going to put the assignment that exactly appears in that solution. And in this way, I'm going to take exactly one vertex from every cloud. And now I'm just going to take all the edges that connect these vertices and what's going to happen that because every constraint is satisfied, I'm going to collect exactly one edge per constraint. So the number of edges here is going to be exactly the number of constraints. So the first solution defines this piece, but then I take all six to the r solutions and they will define six to the r pieces. So in the yes instance, we get six to the r pieces. The number of edges in every piece is exactly the number of constraints. And I'm going to put this limit on how many edges per piece I'm allowed to be exactly that. And so this is going to be the total solution value six to the r times the number of constraints. So now the question, okay, what happens in no instance? And in no instance, remember, we have the same P and L, same number of pieces, the same limit on the number of edges. And what I want to show is that the solution value is low in no instance. So let's look at the no instance. And one thing I would really love to happen is to get an ideal solution that behaves like the solution that we had for yes instance. So every piece I wanted to take one vertex from every cloud. If a no instance does this, I'm really happy because now every piece defines an assignment to the constraint satisfaction problem. And because it's a no case, you cannot satisfy many constraints. So there's going to be very few edges in every piece, and you'll get the solution whose value is very low. So if no case did that, that would be perfect. Unfortunately, I have absolutely no control over what no case does. And it can do something totally different. For example, what would be a completely extreme different thing to do? Instead of taking one vertex per cloud into each piece, we'll do the opposite. Every cloud will sit in one piece. So every piece will either contain the whole cloud or nothing from it. So in fact, let's focus on these two extreme solutions. So the first extreme solution is what I call the ideal solution, what they want to happen is where in every piece, you have a single solution to happen is where in every piece, every cloud gives it exactly one vertex. And I'm going to call it economical honest solution. And the second extreme solution is I'm going to call it economical cheating solution is the opposite where every cloud belongs to exactly one piece. So it's completely containing a piece. And it turns out that it's okay to only analyze these two cases. Because if you take any solution, you can do a little bit of massaging to it. And it's kind of common in this hardness approximation proofs to make it look like one of these two kinds of solutions. So as long as we know how to handle these two kinds of solutions, we will be able to handle any solution. And honest solutions, we know how to handle they're really good for us cheating solutions, we don't know. Okay. So now I'm going to take a few slides to talk about a little technical issue that has a little technical solution. And so if you're not interested in technical details, you can tune out for these few slides. But it's kind of important because so this problem that I showed, you run into it also when you try to prove hardness of dense escape sub graph. And the way we solve it here, you cannot solve it like that in dense escape sub graph, which is why unfortunately, what we do does not seem to help with dense escape sub graph. So let me tell you what is this little technical issue and how we solve it. So I'm going to look at the now instance case and the cheating solution. And I'm going to zoom in on one of these pieces. And it looks like this. So every cloud either is completely contained in this piece or is out of this piece completely. And remember, every cloud represents a variable. So maybe this is x i and maybe this is y j. And maybe there was a constraint between them. So now what would happen in the yes case? So in the yes case, in each one of these two clouds, so each vertex will go to a different piece here and each vertex will go to a different piece here. So in the yes case, I'm going to simply get a matching here. That's all I can collect for this constraint. But in the no case, because both of these clouds sit here, I can take all of the edges connecting them. And that's a lot. That's a lot more than the matching. And this feels like really kind of bad because you kind of encourage to cheat. So it may be like always better for you to take the cheating solution. And in a sense, you get unfair advantage to the cheating solution because I don't really intend you to take more than the matching and you end up taking a lot more. So in this case, we can actually fix it a little bit by cheating. So if we go back to our Hardness Approximation Scheme, I don't really care about this weird graph partitioning problem. I only care about this because it helps me prove hardness of Nodeshine path in grids. So I can change it and, you know, I can add belt and whistles to it to make it harder in any way I like as long as the reduction to this Nodeshine path in grids still still works. So what I'm going to do, I'm just going to tweak it manually on purpose to make sure that this kind of thing cannot happen, that you will not be able to connect more than a matching from a constraint. So specifically how I tweak it is not super important, but let me for complete and show it. So this is the definition of the graph partitioning problem, the same definition we saw before. And now I'm adding a little bit extra to it. So for every vertex in the input, I take all the edges that are incident to it and I partition them into bundles. And this partition into bundles is given to me as part of the problem input. And now I require that in the end, you're not allowed to take more than one edge per bundle. So even if this vertex and all its neighbors end up in the same piece, you're simply, I will not count these edges for the solution. Only one edge per bundle can be counted towards the solution. So in this way, I make this problem a little bit harder, but the reduction to no decision pass still, still works. And thanks to this, we can now make sure that in every constraint, you will not collect more than a matching from this constraint. So how for every vertex, I'm going to take all edges that connected to the same cloud, and I'm going to declare that this is a bundle. And because of this, you're only allowed to take one edge per bundle. And in the end, you cannot take more than a matching. So far, what it actually did, it kind of leveled the playing field. Yeah, this thing is destructive. So it leveled the playing field because it basically what it does, it ensures that the cheating solution cannot collect more than a matching per constraint. But we still need to show that in the no case, the solution cost is small. And in fact, we have no idea how to do this, we really don't know how to do this. And even after all this work, we don't know how to do this. Julia? Yes. So can you explain now the difficulty? I thought, so did you manage to force exactly one vertex from each cloud or not yet? No, no. So right now with this, oh no, no, no. So the problem is you can have a cheating solution. This cheating solution indeed for every constraint, it will only collect a matching no more than this. But I don't know, I cannot turn this cheating solution into an assignment to the constraint satisfaction problem. So I don't really know how to prove that the value of a cheating solution has to be small. I mean, the way you prove it, you need to somehow connect it to the constraint satisfaction problem to show that you have an assignment to the constraint satisfaction problem. But when you do this, when you put these clouds, you know, the whole cloud goes to a one piece, we just cannot relate it to a solution to the constraint satisfaction problem. Okay. Yeah, I just don't very clearly see what, you know, what it is that you can prove about the no solutions. Yeah, so that's what's going to be next, right? Okay. Yeah. So so far we didn't do anything. We actually really didn't do anything. So this ends the technical issue. And if you tuned out now is a good time to come back because now comes like what I think is the main idea and that I'm most excited about it of our reduction is we're going to use cook reductions and not car productions. So let's see what we were trying to do so far. So so far we were trying to do a standard car production. I started from a CSP instance. I built an instance of the graph partitioning problem. And then I proved that if CSP instance is a yes instance, then the graph partitioning problem has a solution of large value. And I wanted to prove that if CSP is a no instance, then every solution of the partition problem has a low value, but I don't know how to do it. So we're stuck here. So instead of going to do something different, I'm going to use cook reductions. So first of all, I'm going to assume for contradiction that there is an alpha approximation algorithm for the graph partitioning problem. Then I'm going to start with a CSP instance. And I'm going to build not one, but many graph partitioning instances. If the CSP is a yes instance, then each one of these graph partitioning instances will have a solution of a high value. It's not going to be the same value. It's going to be some value that we know about. It's some prescribed value. But if CSP is a no instance, then one of these instances will have a solution whose value is too low compared to what we expect. And we can run our alpha approximation algorithm on each one of these instances to distinguish between the yes and the no case. So this is very high level, but okay, one more thing I want to say here before we go to more details. So on top of this, this reduction has to be sequential. So to build the second graph partitioning instance, I need to use a solution that the approximation algorithm returned for this instance. And the next instance is built using the solution, the approximation algorithm returned for this instance and so on. So it has to be a sequential reduction. So now let's see in more detail. So as I said, we're going to assume for contradiction that there is an alpha approximation algorithm for the graph partitioning problem. And I'm going to use this algorithm to distinguish yes and no instances of the constraints of this section problem. So you're assuming an approximation algorithm for the series version, right? You actually get the partition? Yes. Does it mean that you don't know how to prove hardness for the decision version? No. You mean you don't? I don't know. So not just for WGP, but also for the node disjoint path? Yeah, I just think about it in this way. Yeah, I actually need the partition itself. Like if you just give it a value, it's not going to help me. Yeah. Or the routing in the case of node disjoint path? Yeah, absolutely. Yeah. Okay. So we started with our constrained graph as we did before. We built a salmon graph as we did before. It becomes input to this graph partitioning problem. And we applied the approximation algorithm on this graph partitioning problem and we got some solution. And I'm always going to assume that this is either economical, honest, economical cheating solution because any solution can be turned into a solution that looks like one of these. So now there are three cases. First, if the solution value is too low, I know for sure it's a no instance, I stop and I'm happy. If the solution value is sufficiently high and I get an honest solution, I know it's a yes instance because every piece defines a good assignment to the constraint satisfaction problem and I'm happy. I'm done. But the third option is that the solution value is high and it's a cheating solution and I have no idea if it's a yes instance or a no instance. So I'm going to do something different here. So let's look at this cheating solution and remember every cloud is completely contained in one of the pieces. And you remember that every cloud here, it represents one of these variables here. So this cheating solution, you can think about this as if it is partitioning the constraint graph into many pieces, which are small. And it retains many of the edges because the solution value is high. There are many edges that sit inside these pieces. So I can simply look at the solution and the solution gives me immediately a partition of the constraint graph like this into a large number of pieces. And overall, I delete only a small number of constraints. And each one of these pieces is much smaller. So what happened here? So essentially, I did not make the problem much easier. I have deleted some of the constraints. These pieces, they became much smaller, but I can continue and apply the same reduction to each one of these pieces. So now I'm going to think of each one of these pieces as a separate constraint satisfaction problem. And for each one of them separately, I'm going to build an assignment graph. For each one of them separately, I'm going to apply the approximation algorithm and so on. So let's see how this algorithm is going to work. So I'm starting with the whole constraint graph. And then there are two things that can happen. Either I will correctly determine that it's a yes instance or a no instance. Or I don't know, but I can cut it into much smaller pieces and retain many of the constraints. And now I'm going to go and do the same thing to each one of the pieces. So I will reduce each one of the pieces separately to the graph partitioning problem and apply the approximation algorithm to each one of the pieces separately. Now, if I get even one piece in which the solution value is too low and too low is compared to the number of constraints in that piece, if that happens, I know for sure it's a no instance, I can stop and that's it. But if this doesn't happen, then every piece will have a solution whose value is high. If the solution is an honest solution, for example, for one of these pieces, then I know I can satisfy many of the constraints in this piece. So I don't need to keep cutting it and this piece becomes inactive. So maybe these are these two purple pieces. But other pieces in which the solution is cheating, I'm just going to again cut it using this cheating solution. And I will keep going like that until I stop. So what happens in the end? So if at any point throughout this algorithm, I had a cluster, any one of these clusters in which the solution value was too low, I know for sure it's a no instance and I stopped and that's it. That's it. So let's assume that this never happened. What happens then, you cannot cut forever, right? And every time when you cut, you get much smaller pieces and you delete only a small fraction of the constraints. So when this algorithm ends, each one of the current clusters has to be an inactive cluster. And an active cluster means that inside this cluster, I can satisfy a very large fraction of the constraints. But because of the way I was cutting, so in the end, each one of them is inactive. Because of the way I was cutting many of the constraints, they still sit inside these clusters. And so overall, I can satisfy many of the constraints. And I know it's a yes instance. And that's it. So to summarize here, the main ideas that come from this reduction, the first idea is to introduce an intermediate problem, this weird rough partitioning problem. The second kind of observation is that I can tweak it in any way that's convenient for me to suit my reduction as long as I can still show that knowledge and path is at least as difficult as this problem. And lastly, we use cook reductions and not carp reductions. So let me say a few words about these cook reductions and carp reductions or multi-shot versus single-shot reductions. So I was always curious because to me, it looked like the multi-shot reductions should be much more powerful and should be used a lot more. But in fact, practically every reduction that we know of, like single-shot is enough. In fact, this is the only exception that I know of. So it is possible that in this case, too, there exists a single-shot reduction. And we just didn't find it or we weren't able to prove that this reduction works. So it's possible that it's a bug and not a feature. But on the other hand, we did manage to prove hardness using this multi-shot reduction. And we don't know how to do it using a single-shot reduction. So at least in this sense, we can say that multi-shot reductions are more powerful. Okay. So to conclude, we showed almost polynomial hardness of no-digent path in grid graphs. And you can get various tradeoffs between the hardness factors and the complexity assumptions. And to me, the main remaining open problem in this area is congestion minimization. This is where you want to route all the manned pairs. You want to minimize the congestion. So currently, the best approximation algorithm gives you log n over log log n approximation. And we don't have anything better even for planar graphs. The best hardness is omega log log n, but nothing for planar graphs. And in fact, even the integrity gap of the natural LP, we don't know where is the right bound. It's basically between these two. And that's all. Thank you. Thank you, Julia. This is time for questions. It just was very clear. Let me start while everyone is setting up for questions. So I think if I understood correctly that the problem you're trying to deal with is that potentially the constraint graph is maybe not an expander or something. Yeah, exactly. Actually, if I could prove that it's an expander, it would solve the problem and you would get a single-shot reduction. Yes, absolutely. Is that the issue that shows up in the densest case of hardness proofs? So in densest case of graph, you will have this additional issue that in the no case, you can collect all these extra edges. And that you cannot really solve there because you cannot tweak the problem. Yeah, so I don't think that if you only had the expansion, that would help. That would be sufficient. But I was actually suspicious that the graph is an expander. You need very, very strong expansion, and I just could not prove it. I just didn't know how to. So instead, you just got it. I guess the question is, so you're kind of using the Oracle to provide you with that partition. Is there any hope that you can do the partition yourself? I mean, there are lots of algorithms for partitioning graphs into mildly connected components. Did you look into that? So you just want me to take the constraint graph and cut it? You're probably right. If I just keep cutting the constraint graph until I get expanders, then I will not get cheating solutions because cheating solution means it's not an expander. So you just need to check that it's kind of a weird problem in the terms of, you need to preserve a huge fraction. The number of edges you remove. Yeah, you need to be careful. Yeah, it's a good question. Maybe that would work. More questions? Okay, I guess it was all very clear. Give them one more chance. If you don't ask questions, we won't let you in again next time. Okay, so I don't see any more questions. So thanks again, Julius. And we'll probably resume in the spring. So everyone is welcome to stay here. I'm going to take us offline.