 We are online now. Welcome everybody. Thank you for being here. So we're pretty excited to have Denon Pondline on K give a talk on TCS Plus. Before I introduce the speaker, I'd like to introduce the groups. So I'm going to go around. First, we've got Andre, with a group from NPII. Hi. Then we've got Ben Tamemila, with a group from UW Madison. And Erfan, with a group from Indiana University Bloomington. Hi. Fangyi, with a group from the University of Michigan. Then we've got Caltech, Jung Young, from Virginia Commonwealth. We've got K. Gopala Krishnan, from East Carolina University. Mark Selke, from Cambridge University. So next, we've got a group. Sorry, I'm kind of lost. OK, yeah. So I'm kind of lost about which group you are. We also have Sidard, from the University of California, Yavin. They present. Hi. We've got Serahtrae, from Michigan State University. We've got the University of Toronto, with Chris Caravacilis. And yes, we've got Yasamin, from John Lumskin's University. And of course, we've got Danupang, that's going to speak about the disability of the older shortage path, exactly. So the next few schedule talks are going to be, as usual, two weeks from now and four weeks from now. So the first one will be Michael Kearns, from UPEN. And the second one will be Leonhard Schumann. And again, I would like to encourage you to ask questions during the talk after you unmute yourself. OK, so we've got too much more further to do. So again, we're very excited to have Danupang give a talk on TCS Plus. Danupang is currently a professor at KTH in Sweden. He got his PhD from Georgia Tech in 2011 and was advised by Richard Lipton. And has been doing a lot of great work on graph algorithms and distributed and dynamic graph algorithms. Today is going to tell us about a recent result from Fox 17 on computing older shortage paths in the distributed setting, and exactly. Should it be my turn? Yeah, yeah, sorry. Oh, all right. So thank you for the introduction. Thank you for having me here and thank you for being here. Yes, so today I will talk about distributed shortest path, all-patterned shortest path. And I guess you know what I mean by exactly from the abstract. By the way, I just realized that my video is not super fast, so I have another one down here so you could see one of them. All right. So today, this talk will be about the problem is called exact all-patterned paths on distributed networks. And in particular, we will look at the algorithm on a model called congested model. And one point that I want to make here is that the state of the art for this problem is pretty simple. And I really hope that somebody will make more progress. And so one open problem that I want just to leave to all of you now is can we have an exact all-patterned path algorithm that is as fast as the approximate one? And the last point is maybe you don't like all-patterned path problem. And you want to think about other problems. So same problem. Can you validate one for other problems in the distributed setting? So before I continue, I would like to say that please feel free to ask questions at any time. And I think one of my videos is gone, but that should be fine. So free to ask questions at any time. And actually, please do ask questions so that I at least see your feedback. And if you can turn the video on, that would be pretty helpful for me. OK. So here's the plan. So I will start with defining the problem and give you a little bit of a background. And then we will look at the history of the problem a little bit. And then I would, the main part, technical part, will be explaining this, our all-patterned path algorithm with this, which is a Shenzhen one and such one. And then I will just conclude with some final words. All right. I'm sorry. I have a switch. So let's start with the problem. And I will divide this into three parts. I will define the model called contrast. Then we will get some warm-ups with some problems. And then we will jump to our own problem. So just to make sure to get some feedback a little bit from you. So can you let me know if you know already what contrast is? Can you maybe rest your hand? I can probably see your video. OK. Maybe one group out of many groups. So yeah, if you haven't seen it before, here is my way of viewing it. So you just think of a network that is modeled by a graph. And there will be two parameters that are usually important when we want to analyze the complexity here. One of nodes and the other one is D, which we usually call pop diameter. So this is one example. You have any other node in two hops. So this is a weighted graph. But the diameter, we will usually refer to pop diameter, which means you omit the weights. So these will be two parameters. And now as I said, this is like the network of computers. So every computer or every node has its own information. So in the beginning, every node kind of know how it is connected to other nodes to the rest of the node of the world. For example, node number four here knows that it's connected to 1, 3, and 6 with this weight, 4, 1, and 1. But it doesn't know anything else. Local information. And in the end, they want to be able to compute something together. You can pick your favorite problem now. And they want to do it as fast or as efficient as they can. So what does it mean by efficient? So there are quite a few ways to analyze the complexity of algorithms on this model. One complexity that I will focus on today is called time complexity. Or sometimes I usually call it number of days and nights as follows. So you imagine that you start with day and night. Every day in the morning, everyone gets to send log-in bits of messages to everyone else. Picture I just... But you can actually send log-in bits. And then in the evening, the message arrives. And at night, everyone got the message and do their own local computation, meaning that they cannot talk to each other anymore. But we will assume that they have a free computation, which means that they can solve any problem they want. If they want to solve any hard problem, that's fine. Then open just a small comment. Apparently the connection is a bit spotty. I don't know if it's just on my side, but maybe try to remove VLC, the VLC video that might solve it. In case that's... Okay. Yeah, that's... Oh, sorry about the interruption. I need to find a way to remove it one second. Is it better now? Yeah, it looks pretty good. Thanks. Okay, okay, okay. All right. One more thing. Okay, so... Now any... I guess I just already said that any calculations can be done in one night. And then the next day, again, every node sends a message, log-in bit message to everyone. And then again, in the evening message arrives at night, they do local computation again. So the computation goes on like this. There's a night. And if you can finish whatever you want in three days, then we will say that the time complexity is going to be T. Okay? So if this is not clear, we will see some examples. But first, let me make some remarks. First of all, this is called Conjess model. And you may imagine that there are many other models in distributed computing. For example, one model that probably you see when you go to Fox Talk is called local model, when we have no limit per day. And distributed computing is more than that. Usually other model, one assumption that we usually share is that we have free local computation, and we only count for communication. And you can see that the Conjess model is like that too. So number of days that I mentioned is usually actually called number of wraps. And in this model, there are actually I make many assumptions. We have global clock, which means that everyone wake up at the same time and they get to send message at the same time. No failure. If you send a message, it will arrive and no delays. If you send a message, it will arrive in the end of the day. And we will make assumptions so that everyone has a unique idea, meaning that everyone has a number that is different from others. And it will be... And as I said, free internal computation. All these assumptions were made just so we can focus on one issue for today, which is the congestion issue. And maybe some of you might ask, can we assume that we know N and V because it might make our life much simpler? And yes, you can at least assume that that is the case approximately. And the last thing is that in this talk, I will ignore logarithmic terms most of the time. So if somewhere you think it has to be there, I think you will be right. So maybe this is a good point before I show you some warm-up questions. Any questions for now? I guess not. Then I'll move on. So now I will give some warm-up questions. So the first question is called unweighted ST shortest paths. So here's the problem. So you have two special nodes, S and T. And in the end, what do you want to know? And this graph is unweighted, by the way. In the end, you want S to be to tell, to say out, like the distance to... T to say out the distance to S. For example, in this case, T should answer 2. Okay, so that's the question. Now, if you just think for maybe 10 seconds, you'll probably realize that there's a simple algorithm for this. And it just takes the diameter time. If you don't see it yet, here it is. So basically, you just run the first search algorithm, which looks like this. In the first day, the first node S, the node S will start the D of S, the brace search algorithm. So it basically just tells everyone that this distance is zero, because it's the source itself. And then at night, the neighboring node will be able to compute its distance. So now they will say that the distance is 1, which will be announced the next day. And then at night again, the message arrives that the neighbor of S will know that the distance is 2. So if you're reading this, you can see that in diameter time, everyone will be able to say the distance to S, right? And then they're done. So in D rows, everyone can say the distance. In part of the D can say that the distance to S is 2. Any question about this one? So if not... So, yeah. And it turns out that this is the best you can do as well. So you just need D rows or D time. Now let's make a problem a little bit harder. So next problem will be unweighted all pairs of shortest paths. Still unweighted. So what is the goal? The goal is that every node should be able to say in the end what is its distance to every other node. For example, here node number 6 should be able to say that one is 2. Number 1 is 2. Number 2 is also 2 and so on. Okay? Let me emphasize that every node just has to know its own distance to everyone else, but not the distance between every pair. That is a different problem. Okay, now what can we do? What... I'll just give you 5 seconds to guess what is the running time you need here. So simple algorithm that maybe you would think of is running the breast first search tree from every node. So every node just running breast first search tree. Does it work? One problem that we have to worry a bit is that maybe there will be some conflict between algorithms. Meaning the following. Look at this example. If you run breast first search from 1, 2 and 4 3 nodes. Of this, when you run these 3 algorithms at the same time you will send node number 3. You have to tell node number 6 that its distance from 1, 2 and 4 is 3 at the same time. So it has to send 3 messages and you can imagine that if you have more nodes, it might have to send more and this would be a problem if we have too many nodes because in one round you should be able to send only a log and a bit through an edge. But you don't have to worry about it. So one point I would like to make here is that all you have to care is the total number of congestion or we just call it total congestion. What do we mean by this? So there's one pretty general theorem by Gaffari from PODC 2015 and actually if you just want to talk about all patriotism part, you just need something simpler which is by Layton McEnroute. It's called Random Delay Technique. So the theorem says the following. So if you want to run many distributed algorithms in parallel at the same time and now the congestion to be the upper bound when you look at overall algorithm over all the rounds all the time to get how many bits you have to think through an edge that is congestion. Okay, let me read this out. Overall algorithms and round the congestion we see at most congestion bits sent through each edge. So if we define the congestion this way and please remember this notion because it will be useful to understand our algorithm later. So then if you define it this way then we can construct a randomized algorithm with the running time or number of congestion plus T where T is the time of the slowest algorithm. So basically if you run many algorithms at the same time what will slow you down is the slowest algorithm among many algorithms. Hi, Dhanupan. Dhanupan, the question. Yes, Dhanupan. Yeah, so this I mean you're doing something heavyweight, right? We already know how to do this in low-offend time, right? I think there's a paper by Roddy T. but they would even deterministic low-offend, right? Yes, yes, yes. But this gaffari thing is too heavyweight. It's too general. Yeah, but it's heavy but it's heavyweight. That's why I want to introduce it now. Okay, so yeah. It's good to remember it for now. Any other question? Okay, so I hope if you don't understand please ask me. I can explain it again. Dhanupan, sorry, I'm still asking. So the main thing, so the latent max row is just the congestion plus dilation, right? You just, is it the I mean just due to a random delay, right? Is that the thing? Yes. So, but there's a lock factor or he removes the lock factor Gaffari. Yeah, as I said, I always ignore. Okay, so this is just random delay. You start the algorithm with some delay and then that's it, right? Is that the same? Yes. Yeah, so in the end the trick is that you want to start different algorithms at different time, at different like random time. Okay. Yeah, and now just to make sure you understand this theorem because it will be useful to understand algorithms later. As a corollary, now you can solve unweighted or cashless part in all n time because you are just running n-brain-first search algorithms and for each algorithm, every node we have to speak only once if you recall how the brain-first search work. Congestion will be just n, so if you plug in this theorem t will be d, diameter and congestion is n, so the total time you need is n. Any other question? Now I will move on. Alright, so now our problem. Our problem is just similar to this unweighted or cashless part except that now the graph is weighted. So this is the graph, one example and in this case, you know maybe the shortest part will look like this from 1 to 6. And again, every node knows this local information how it's connected, what are the weights, the edges. So let me emphasize two things. First, the weights of the edges do not affect communication. So this way between 1 and 4 of wave 4 although the weight is 4 the time you need to send a message from 1 to 4 is just one round or one day. And another assumption which typically may is that we typically assume that the edge weights is in the range 1, 2, 2 polynomial of n. The integer that is not too big and one advantage of this is that to send the whole weight you just need one round because you just need log n bits or big O of log n bits. So now what can we do with this problem? I will just start explaining a few algorithms that maybe you can try to come up on your own for now. One trivial algorithm is just to collect the whole network to 1.0 and you know, since we assume that we can solve any problem in 1.0 locally. So everything you can solve NP complete problem if you want. And so how much time do you need to collect everything to 1.0 is just congestion, right? Because again, you just imagine that you send the input, you know, the information from everyone to 1.0 and then maybe there will be one edge that everything has to pass through and that will cause congestion of number of edges. So that's the time that at least we should try to beat the number of edges. So now one question is can we improve the trivial algorithm? So let me discuss two algorithms that we probably know from the textbook what we can say about them. So the first attempt and I hope you remember this because this is one sub-routine that we will need later. So what if you run breadth-first search from every node? So what do we mean by this? It means that I would just pretend that my graph is unwetted by, you know, sub-dividing the edges. So for example, the edge between 1.0 and 3.0, you have where 3.0, so I just put two nodes in the middle so that I have three edges in between. And then I just run breadth-first search where in the first row number one here just send to the neighboring you know, red nodes instead of, you know, node far away. But you will realize soon that it's not hard to see that this algorithm is going to be bad. It's going to be too long if we have a large distance between some pair of nodes. Because you really sub-divide the edges. We don't have any good guarantee here. So another attempt as a second algorithm is Bellman form. So the algorithm is pretty simple. Every time you learn about the distance of someone, you just tell that to your neighbors. So in the beginning, you just, you know, send out your own distance which is zero. And then later if you start knowing some distance, you tell that to neighbor. Let's look at example here. So maybe at some point, node number six here node is distance to node number one through this red edge. So the distance would be five. So he will tell this to everyone. He says five. But maybe later on he discover a better path like this. Then he has to again announce the new path which is four. Okay? And maybe he has to do it again and again and again, right? And he has to do that about what he learned about distance to node number two and two. So he has to do the same thing for every pair you know, every node. And so one thing we can say about this is that the change of the distance from six to one, it will change only in times. And if you want to convince yourself quickly just look at the shortest path three rooted at one. The next round of the Bellman Ford, the node in the first layer of that tree will get the correct distance and the next round it will be the next layer and so on. So in the end you can borrow the total number of times that some node has to say something to be n squared which means that we have a congestion of n squared. So conclusion is that if you just run Bellman Ford you will need n squared rounds which again is disappointing I guess because it doesn't need the number of edges like you know, the trivial argument. If not let me just summarize and if you want to ask questions before we move on just let me know. So summary of this part I'm going to introduce you to the problem and the main problem that we will look at is the distributed weighted LPF shortest path. And we I have shown you two algorithms as a warmer that doesn't work multiple you know running breathers from every node these words for un-wetted cares but not for the weather cares and Bellman Ford algorithm they don't be the trigger algorithm but as I said remember these algorithms they will be useful later on and in part of that things that will be useful to remember first the congestion only the congestion matters in the end you just need to understand how long the algorithm takes and how much congestion it costs and we have these algorithms that run multiple breathers first. I have a question could you go back to the previous slide I was just wondering how is the congestion in squared? Oh right so if you look at node number 6 right you just count how many times node number 6 has to say something out okay and the claim is that he has to send an update of his distance to node number 1 only n times okay so if you don't see that just accept it as a fact to do with the breathers search tree sorry third shortest path 3 okay and now he has to send but he has to send an update of his distance to n other nodes you know he has to do the same thing for distance from 2 distance from 3 and so on right so in total you will see he can speak out at most n squared time so he will update at most n squared times yes and so this implies that the maximum amount of information in an edge is n squared right because every time if you look at some edge between 4 and 6 when do you need to send some information on this edge it's going to be when node number 6 says something or node number 4 says something right and node number 6 as I claim is going to say something which is when it wants to update its own distance okay does it make sense? and the same thing node number 4 will say its own distance n squared times okay thanks just a quick clarification yes but more accurately it's n times some kind of yes where s is the shortest part diameter the distance right yes so if you if you want to introduce another parameter it will be n times the depth of the shortest part 3 basically that's what I'm calling as yeah that's what I'm calling as shortest part diameter this yes yes but I don't want to introduce another parameter okay so that's the conclusion of this part one now if you don't have any other question I will tell you a little bit of what happened so far and there will be quite a few information but if you don't want to bother with a lot of information this slide should be enough for you so basically what we know is that this problem requires omega of n times even if you want to approximate the distance and I will just tell you why soon and also if you allow approximation you can actually match this running time of all n so all n is the best you can do with one plus x one but it turns out that for if you want exact solution the best we can do is n to the 5 over 4 which is going to be the next part of this talk now let me tell you a little bit about what happened my point is that everything is I think the state of the art is pretty simple at least on this page so why do we have this omega n lower bar just think of this graph where you have a star look at one particle and note note number one here so now how can one and let's say that the way of the edge from one to two is zero so for one to be able to say the distance to everyone else it means that it has to learn about the value of the edges of all other edges in this graph and since these values are independent it's not hard to argue that you will need n bits to send through the edge from one to two so this is an informal argument but you can make it formal pretty easily okay so n is pretty obvious lower bar and the upper bar is also not hard so I already told you that there is this one idea that you created just a clarification hello yes but this omega n also follows from that diameter in approximation but then you have to talk it's not for any approximation argument first of all if you talk about unrated graph does that answer your question Gopal but even for that let's keep it on so but even for the diameter the diameter shows the approximation even for unrated graph yes but that's not for any approximation that's true and it's a little bit more you don't need that at least for the weather but you are absolutely right okay and I already told you before that you can just one idea is to subdivide every edge by the way and then run great research from everywhere but that's a bad idea however if you are happy with some approximation some errors then it turns out to be a good idea so let me just give you an example here so look at this graph on the right and now you see that I have this way 39 what if I change it to 40 basically what if I change every edge width to a multiple of 10 and then I just divide the edge width by this you know by multiplicity of 10 for example if the width is 40 here then I just put 3 nodes so you have 4 edges here and then run great research algorithm so instead of having 40 you know steps on this edge from 1 to 3 4 steps so I can just save something out and by you know balancing parameters correctly you can just use this kind of trick to make sure that you don't have much error and the great research algorithm can finish in open routes so that's basically the idea you just by allowing some error you can run great research from every node so any question about this part so then ok now this is pretty much what you need to know about all characters part in the weather test to start with but now let me zoom out a little bit and talk about more general problems for other cases first of all let's talk about this is the complete more complete problem of the all characters part problem I already mentioned the weather test here in the red was already study as well as Gopro pointed out and you can also prove the lower bar of omega n and in fact it holds even for the simpler problem called the diameter and even for some approximation algorithm but not for any it's just for some and we have an upper bar which is deterministic and that matched the lower bar as well so and also for the weather test you can get the deterministic algorithm as well that is by Lensland and Pashamere so basically for the unwetted exact and for the weather approach in both worlds you get a tight upper bar deterministic but for the weather exact for the green card here at least up to 2016 we don't know that just the trigger often where you collect everything to one note that was the state of the art and an obvious question is can exact often be as fast as can we get all in time for the weather exact and actually now let me zoom out even a bit more and again if this is too much information for you for a few minutes I will wake you up so if I zoom out a little bit more you can actually ask the same question for many other problems so what happened is that in the distributed setting in this congest model in the last two decades we know quite a few upper and lower bars for the lower bar size we know lower bar of basically two forms actually we know a bit more now but these are the common two forms one is in the form of root N plus D and it usually holds even for some approximation algorithms and this holds for example single source shortest path minimum spanning 3 many others and the other kind of running time is omega N this is for all shortest path diameter and so on and then if you now from the algorithmic side from the algorithms point of view we have kind of tight approximation that has been developed in the last 10 years in the following sense so for problems like single source shortest path minimum spanning 3 and so on we have root N plus D upper bar but it's a one plus epsilon approximation so pretty much it's meshed the lower bar stated above and for problems like all shortest path and even you know diameter and so on you have big O of N upper bar and one plus epsilon approximation which meshed the lower bar above as well so you can ask the same question can exact algorithms be fast be as fast as the approximate one for all these problems and to me asking question for all shortest path is a good starting point because the literature seems much simpler than other problems and what we know so far up to these days that I will just that I will tell you in the next slides is that we only know it and only for the shortest path problem so now let me zoom in again to the shortest path and again if these kind of confuse you you know go sleep for a few minutes if it's too much information so let me remind you what happened so far so until 2016 we know that for single source shortest path we have a lower bar of root M plus D which for even for approximation algorithm for exact algorithm however the best we know is just bare man form which has O N time and for all path shortest path the best lower bar is O F omega N the best upper bar is O N for and is one plus F for an approximation the exact algorithm we don't know anything now we start to know quite much more than in 2017 so first result is by Sankoski for single source shortest path so he got this running time you don't have to worry about it too much about you know exact what this means but basically this can be written as little of M something smaller than running time of this kind, little N plus D so it getting closer to the approximation algorithm looks like but it doesn't match the lower bar and then for the all path shortest path there are two independent results one result is by by Elkin and the other one is by is as I'm talking about this talk by me and Sharon Ruck so Elkin got N to the 5 over 3 which is to be better than number of edges than the 3D algorithm and we got N to the 5 over 4 this is the best algorithm so far and I think one interesting thing about this result is that it's also the first paper that the scaling technique in the distributed setting and because of that there are two later it kind of leads to two independent results for the single source shortest path so these two and I'm not going to go into much details but the currently the best algorithm is by this one by Sebastian Kruniger and I so a summary of this part so we know a lot of quite tight approximation algorithms and we have some progress on the exact shortest path problem and the state of the art for all shortest path is pretty simple right now so I really hope that somebody can push further and get something better for all shortest path problem that would be the first problem and the other problem is can you prove some gap between exact and approximation algorithms for some natural ground problems and the last question is can we get the running time of the kite little other problems like mean card, net flow, matching and so on so before I move on and explain our algorithm maybe it's a good time it's a good time for questions again so I guess no question so so then now I will start explaining the algorithm I'm kind of the organizer please correct me if I'm wrong but I think I will have only 10 minutes so I will just just as Describe the algorithm briefly just to give you how this looks like so this is what we want to prove just one more time I just want to show that this with all paths to this path the exact weather case can be solved in n to the 5 over 4 time so and this part will be organized like this so first I will talk about the scaling technique which you probably have seen before I have mentioned it before and then I will talk about two special cases that we should solve first the first one is called H-HOP all paths to this path and the second one is called reversing the knowledge and then I will tell you how to put everything together start with the scaling technique so as I said before this technique was known for a long time from Fox from 30 years ago it was used in many classics centralized algorithms and basically you can think of it this way it is a way to reduce a problem a weighted problem to an unweighted one with simpler weights actually no, not unweighted but something close to unweighted it will have simpler weight structure and the idea is that we will have many iterations and in the I iteration we will look at the I bit we will solve the problem at the I bit so this is one example here in the first iteration you will look at the first bit and then the next iteration you will look at the second bit and so on of the weights so this is a little bit more detailed example suppose I have only two bits in the graph, in the weights so the weights are number three in the first round I just construct a new graph where I just pick the first bit here and then I just solve all paths to this path here and then using some magic formula I will look at the to construct a new graph but the graph now look a bit more complicated it's a weighted graph for example and then you solve the problem on this graph and you keep just repeating this if there is a third bit then you look at the third bit you solve the problem on the third bit and once you are done now you just claim that the result will be just the shortest path then to get in the last graph for example here in G2 this is the shortest path so the blue the thick edges here the shortest path that is the shortest path in the original graph so how does the scaling help the idea is that you can see that the weight is pretty simpler compared to the original graph for example if you look at the first iteration you only have weight 0 and 1 so it's much simpler than the original care and in other iterations it may be more complicated but something we can claim is this you have first of all we have weighted diameter or N meaning that the distance between every pair of nodes will be at most N you can see that this is trivially true for the first round but it's also true for other rounds but it also creates some complications first of all it creates the graph that you have to look at it's going to be undirected in the sense that the weight from 2 nodes from i to j will be different from j to i you can call it asymmetric or directed and the weight might be 0 even if you start with a graph without weight 0 ok so from now this is going to be what the scaling technique gives us and so from now on I just going to remember we just have going to solve the problem on this structure if this is too complicated for you just assume that the graph is 0 and 1 but note that this is a bit too simplistic so sometimes if you solve the problem on that case it's not going to solve the problem on the general case any questions so far I guess not ok so now we know something about the scaling technique now I'm just going to tell you two special cases that we want to solve so the first special case is called H-HOP APST so the goal for H-HOP APST is that you just want to know the distance but it's not between every pair but between every pair such that the shortest path between them is at most h so you have a parameter h here for example let's look at this example quickly so the shortest path from 1 to 6 in this graph is 4 but if I set h to be 3 then it means that 1 doesn't need to know the distance to node number 6 ok so this is a special case of the all pair shortest path because if you solve all pair shortest path you know the distance between every pair and H-HOP these times just as for something less it's just between pair that is not too far away in terms of shortest path ok so what do we know about this problem if you solve the problem that easily you can just solve you can just write Bellman form for h browse and it's not hard to analyze that the running time of that Bellman form will be N-H so I have some explanations but since I'm running out of time again it has something to do with shortest path 3 now what we can show is that this problem can be solved in N-root-H browse so we improve this dependency on parameter H a little bit more ok and this alone actually gives you N-root-H already so since I'm running out of time I will just give you an idea quickly the idea is that maybe let's just look at this graph what you don't like about the graph that we are looking at right now is that you don't like zero edge width so what we are going to do is that we're just going to change zero to something else and then we just run breadth-first search tree from everywhere and then we will look at use the fact that we are interested in the shortest path that has at most the error that you're going to get is going to be small in particular we're going to have additive error of something called of root-H and we can fix that error using bellman form algorithm so you somehow kind of mix this breadth-first search tree with bellman form algorithm to solve the problem faster so that's the first part I'm just going to skip detail also don't feel too pressed by time you can take a few more minutes if you want we started like a few minutes late and anyway I mean it's not a strict limit okay thank you for letting me know that's great but can you raise your hand if you actually want to know about how we solve this more I already said I saw some so let me go slowly so imagine first that if you don't have zero edge way meaning that everywhere is integral it's like 1, 2, 3 and so on what you can do is just run breadth-first search tree from every node and you can analyze the range of that to be on why is that because I know that the weighted diameter is on so you know if I just pretend that if you have unweighted graph you just run breadth-first search tree for all n rounds and the condition will be just all n so in the end you just need all n time which is great it's even better than what I claim but now we cannot run breadth-first search tree because of this zero edge width so what we can do is we can change it to something a bit small and the right parameter turns out to be 1 over root edge and then we can just run breadth-first search again if you look at the graph on the left side here so now I change it to the graph on the right side and I am going to subdivide every edge by a factor of 1 over root edge so if the edge width is n before like edge between 1 and 2 I will see n root edge nodes on this edge and now I run breadth-first search tree here so now the running time of the breadth-first search tree to go from node number 1 to the last node will be n root edge actually from 1 to 2 already you need n root edge so now this step when you run breadth-first search tree you will need n root edge time and what does this breadth-first search tree give you is the distance in this new graph which is not the real distance in the original graph because you have some error but since I introduced only very small width or the zero width edge I can bar the error at least for the small path so I have this error of 1 over root edge for each edge and I am interested in edge edges so the error will be just root edge and now I run bellman form and if you recall what does bellman form it tells you kind of broadcast distance every time it improves its own distance to someone else but you know that you already have distance but that is pretty close to the real distance so they don't say something too often some people say only n root edge time and that's why we have n root edge upper bound in the last step so that's a run quick question dhanapan yes goho yeah so this is only for 0 1 weighted graph this h of a p s p you are doing in n square root of h rounds what about I guess this is only for the first iteration the scaling right later the weights not 0 1 no yes but if you look at this example at h scale right it's also not 0 1 in the first case so the important thing here is that you are only excessive in shortest path that contains h s s so the weights are not important the weights are important the only important thing is that the total the weighted diameter of m to begin with again sorry I didn't get the weighted diameter is before of n oh that's okay so but why are you saying in your slide 0 1 weighted graphs you are only saying 0 1 oh I'm sorry I should say that for yeah if for 0 1 weighted graph it's easy to see and it works for general weight weight structure as well so the so but even in general the difficulty is 0 weights yes because you cannot run weights versus 0 weights it's gonna you cannot make progress yeah it's not trivial to see that but you know breast versus you want to make progress all the time what about the arbitrary weights like there can be many classes of weights so even then it's a issue it's fine as long as the weighted diameter okay I mean that is the shortest per-diameter is that the shortest per-diameter now the weighted diameter weight diameter is that the same as the shortest per-diameter that means the number of edges in the long the number of ops the distance between every part of no the number of the maximum number of ops in the diameter right no no no the distance between every path. You mean the weighted distance or the number of ops? Weighted distance. So since I'm running on time, let me take, go for it. We can let me take your question maybe later or offline. All right? So sorry, sorry, sorry. That's kind of rushed over before, but like. Sorry, did you say something? Yeah, I mean, maybe the confusion is coming from like definitions come in that you talked about in the slide or two before. Sorry, sorry. Oh, sorry. Yeah, so, yeah, so, so, but I guess I, so when I say weighted diameter, it means that, you know, the distance, like the really, the real distance between every path. OK. I, yeah, sorry. So if you, if you have more questions about this case, maybe I can take it maybe after, you know, after everyone, you know, we be finished or something. So now let me just define another special case. So reversing the knowledge is a fresh problem. So even if you don't understand what happened before, you can still understand this case. So the problem is this. So it's called reverse r-sync choice paths. So in this setting, you just have r-sync nodes. And we assume that every node v knows the distance. v-t, we basically, the distance to the sink. So for everything t. So if you look at the picture, this node v and this sink t, we know the distance to t already. In the end, what happened is that t already also know the distance to v, OK? So again, why is this, why is this social case of all-patterned start? Because if you solve all-patterned start, t will automatically know the distance to v. So you don't even need this extra knowledge, OK? But now the question is, if we have this extra knowledge, can we do something better? And again, the trivial organism is just nr-routes by just sending all this distance pair, like broadcasting. You can see that the congestion will be just nr. So we show that actually you can do a bit faster. You can do n root r. And since I'm running out of time again, let me just say quickly. So the main idea is that you want to send the distance through the shortest path, send this knowledge. But then maybe some node or some edge have to handle too many information. And in that case, we're just going to identify that edge and just broadcast the distance. So we will identify roughly root r, spatial nodes, with a lot of congestion, and handle that separately. And for nodes with small congestion, you don't need to worry too much. OK, so here's a summary of this part. So we have three tools, a scaling technique, which allow us to have simple way structure. And in particular, the way that they emitting this O-n. And we can solve the edge hop, API, or edge-less path, which means we are interested in just shortest path with small number of edges. We can do it a little bit faster than 3DL, faster than n-ish. And then we can solve the reverse knowledge, or reverse, R-sync shortest path problem, a bit faster than 3DL, which is n root r. And now you just combine all these steps together. Just the idea why we get this running time of n to the 5 over 4. The idea is this. This is not completely correct, but it's just intuition. So if you just run the algorithm naively, you'll collect everything. And the first two tools together kind of gives you the first improvement over this n, so it becomes root n here. And then the last two, if another root improvement, so it becomes n to the 1-4 over here. So I will just state the algorithm quickly, and then I'll just skip to the conclusion. So the algorithm is just you just have four steps. So you sample root n spatial nodes called centers. That's the usual thing you should do for the shortest path. And then you run these first two edge hop, or pair shortest path. And then you broadcast these times between every center of reverse knowledge. And the last step, you have to run the first two again by a modification of it called modified edge hop, or pairs shortest path. It might not make total sense to you why we do this. If I have 10 more minutes, I can explain it to you. But since I don't, let me skip the analysis and just jump to the conclusion. So Danupal, follow? Yes. Yes, Gopal. Just a question. So this is the property of the scaling algorithm that the weighted diameter is O of n? Yes, it came. That's what Steady gave you. So regardless of the weights? Regardless of what the weights are? Regardless of the original weights. Yeah, regardless of the weights. Regardless of weights. And second is what's the message complexity of an algorithm? It can be m times the number of rounds. I haven't analyzed it, but I would guess it's really a lot. But it can be as much as m times the number of rounds, right? That's the point. I guess so. It's just I didn't analyze it. All right? OK. OK. So OK, conclusion. How is this part? Basically to me, it's like you just, this code word, the scaling technique can be useful. And then there are some two special cases that turn out to be important. And we somehow hack away to get some improvement for two special cases. So an open question for you. Can we at least solve these two special cases, or one of them, in orient time? Right now, I don't know how to do that. And how about single-searched as part? As I said, once you found out that scaling technique can be useful, Gaffery and Lee can use it with some other techniques, can get some improvement. And I and Sebastian Kriniger get further improvement. But that came from viewing scaling technique from a different perspective. In particular, you should think of it as approximate, this time approximation algorithm, but with some constraint called no local improvement. I think it's pretty nice view. And if you want to know more, either read our paper or the original view actually came from Klein and Supermanian. So maybe you can read that as well. And we know a lot of tight approximation algorithms. But I think we still don't have much progress on understanding exact algorithm, especially shortest parts. So open problem, the first one, can you solve shortest part as quick as the approximate one for single-source and all pairs? And how about other problems? How about do we know anything that is in between, that has any time between n and n squared? All pairs to this part right now is one candidate, but I'm not convinced that it will be the case. So we'll see. So thank you for your attention. Let me know if you have more questions. Thanks. So yeah, if there are any questions, now is the time before we go offline. Thanks for the talk. What is the best for SSSP now? What is this new result? Yeah, it's this one by this one. Chronicle and the running time is complicated. You have two algorithms. So basically it's the minimum between root and V and root and V to the one-fourth plus something. Another question? OK, we can also take questions offline afterwards if you want to stay and ask more. Before we do so, I'd like to mention that the next talk is going to be two weeks from now again. It's going to be Michael Kearns from UPenn. We had also 10 viewers on YouTube today. And again, before signing off, I'd like to thank again Dan Upon and also behind the scenes, people helping for TCS Plus, Anindya Day, Gautam Kamath, Razenstein, Oded Ragev, and Thomas Vedic who is also here today. Thank you. And we're going to go offline now.