20842
>> Yuval Peres: Okay. Hi everyone. Today we're happy to have Benny Sudakov from
UCLA, and Benny will talk about all-pairs shortest path and order N squared with high probability.
>> Benny Sudakov: So thank you for introduction. So it's a great pleasure to be here.
Actually, very impressed to see so many people in the room taking into account that at
4:00 there's a competing event of wine and cheese. So hopefully this talk --
>>: You'll be impressed at 4:50.
>> Benny Sudakov: Hopefully at least this talk will be worth your while and another disclaimer, since people are mixed here, I will try to kind of present the talk which would be accessible for most people who are more on the probability side as well as the computer science.
So some things would be probably well known for one side and some things would be well known for others. But just take into account why I'm doing so.
So this is joint work with Yuval Perez, D. Sotnikov [indiscernible], and also Dema and
Yuri Zwick from Tel Aviv. So I'll talk about all-pairs shortest path problem.
So A -- okay. All-pairs shortest path. Okay. So what is a problem? Let me describe you.
So we have a graph G. D. So they're the set of edges. And we have also the functions, the weight function. W from the set of edges to the positive reels for this talk. And what
I want to know -- so the goal, find DUV for all U and V, which this is the shortest distance.
The length of the shortest path. Okay. Length of shortest path from U to B, using the edges of this cup. So this is a very classical problem in computer science. I will not go in too much depth why it's important. Just if you go to Google's caller and you write all-pairs shortest path you get more than 200,000 hits. So this was a well known problem. So one of the basic ways to solve this problem one can use a Dijkstra algorithm.
So let me say what Dijkstra does. So the Dijkstra is an algorithm which finds DUV for fixed U and all V. So it's algorithm from which the given vertex finds your distances everywhere in the graph. And let me tell you the algorithm just to be on the safe side and actually to kind of get used to shortened sub routing. So what you do, you start by setting the distances UV to be either the weight of the HUV or infinity if there is no H. No
H.
Then you put all your vertices except U, put all V not equal to U into priority queue based in the key for the priority Q is just the distance from U. And the sub routing which you perform, you extract the minimum V with the minimal key. Okay. And then for all

vertices V prime adjacent to V you compare what their current distance from U is with the way to go first from extract -- yeah, this was the vertex V. With a way to go first from
U to V and then adding the price of this H. And you compare this. Sorry, other way around. And it's happened that it's cheaper to go through V, you update the key.
So that's very simple algorithm. You can prove that it's indeed output and then all the numbers which are output, it's shortest path. Every time something was extracted from the queue it also gives you distance of U to V. And just an important thing, how much time it takes. So time, it's M. M would be past always the number of edges.
Plus, of course, up to constant. Plus N log N. N is always the number of vertices. And I need to explain from where this term comes, because we will keep this Q in the way of some data structure, for example, people will use some let's say [indiscernible] naturally and the costly operation here is to extract the minimal element. This operation costs you log N. And you do it N times. So it's from where N log N and everywhere else we just look on every H once, constant number of times that's why we're paying them. That's the operation.
So the total time is big O, total time, because perform Dijkstra for every vertex. And then, of course, you get all distances. And the total time would be MN plus N squared.
Okay. So that's, for example, an algorithm. And there are some improvements over this algorithm. But one thing to note is that this can be pretty big, especially if your M is quadratic in it. So one question which people study when they are talking about algorithm. They say, okay, so that's worst case scenario. So suppose your instance, your graph comes from some random distribution. Maybe you can do better. And one of the most kind of studied, most natural models on which to look at is the following random model.
So we have KN complete. Directed. So for this talk I will assume that my graph has direction. So the length of the HUV and the length of the HVU is not the same but what
I'm saying similar result can be obtained also in symmetric case. So you have complete directed graph. And then WUV is just uniform random variable in the interval 01. So all your weights are uniform random variable in the interval 01. And you ask the same question. So question how fast you can compute all-pairs shortest path.
So one observation -- so claim. It's Frieze and Grimmet [phonetic] I think was done by
Hassene and Jemel [phonetic], is that there is algorithm which runs in time algorithm.
So let me just say a few words why this is possible. Because potentially that's what I said. If you look on this Dijkstra algorithm, this M, the number of edges comes here. So this graph has N squared edges. But if you use this blindly then you get constant N cubed. But the observation which I make, there are only order N log N relevant edges.
Why there are order N log N edges, in order to be relevant it should be on some shortest path and in particular itself it should be the shortest path between two vertices. What you can show, I'll show you in a second because it will be important for us -- you can show in this model the distance between any two vertices cannot be much bigger than log N over N. And therefore if you ask if your random variable is uniform in 01 and you ask what is the probability that it's at most log N over N, then the probability of this is with log N over N and you multiply it by N squared so you expect only N log N relevant

edges, N log N edges which can be on the shortest path instead of M here you'll have N log N and this equalizes.
So lemma actually by Yon Sun [phonetic] and [indiscernible] says that in this model, now
I will only talk about this random model, the distance between two vertices basically behaves like roughly N log N.
>>: In the analysis of the algorithm to make sure you never actually look at the edges?
Right, so all these edges don't contribute to any shortest path. I don't see why it's obvious that you're never --
>> Benny Sudakov: I don't know. What I'll do is if you give me the graph, then I span N squared time by deleting those edges, whose weight is bigger than that and then what's on left I'll run the algorithm.
>>: Okay.
>> Benny Sudakov: Because I know that these guys like maybe five times log N over N will not be many shortest path. So I will in a second show you, because this will be also instructive to what I'm going to tell you. Just one remark. So all the results which I will talk about, you don't need to know too much about this distribution which you put as a weight of the edge. So, for example, instead of taking uniform, you can take its equivalent, for example, to exponential distribution with expectation one. You can do exactly the same computation, more generally any distribution whose distribution function at 0 is 0 and has derivative 1.
So there is some very general kind of public argument, very simple, which basically says that, for example, this result would be true if you improve it for the exponential weights, it would also be true for uniform weights and so on.
Any questions so far? Okay. So let me just briefly tell you the proof of this lemma. So we do -- so one way to think about this, it's like it's convenient from probability point of view. It's to do percolation. So you start with the vertex V. You're trying to find the distance between V -- with the vertex U. Between U and V. And you think that there is the V is infected. You inspect it at time 0. There's a disease which spreads along the edges with the speed which is exponential distribution. That's exactly the length of the
H. So instead of uniform, I will now think about exponential distribution.
So the probability -- so the distribution function of this guy is 1 minus this one. The density to the minus X. So you look how much it will cost you the first stage. What is the light test edge from mu. Here N minus 1 vertices. So it's the minimum of N minus 1 exponential 1 distribution. So the first edge, the lightest edge which comes from U to the world, next vertex which would be affected by the disease, it happens in the time which is a minimum of N minus 1 exponential distributions. And this random is itself distributed exponentially with expectation 1 over N minus 1.
Time until second vertex infected. Distributed like X1 over N minus 1 by X1 is just exponential distribution. Okay. And similarly, if you already infected K vertices and there are N minus K vertices left --

>>: The length of the edges the time spanning?
>> Benny Sudakov: The length of the edges and the time spent until --
>>: Exponential --
>> Benny Sudakov: The length of the edges and the time spent until you infect, the length of the path from the vertex until the next vertex is infected and the time it's exactly the same thing. So if you think about it, the first edge is exactly the length of the shortest path from U to the next vertex I discover. Now, conditioned on the first edge was certain length, if I know that all other edges from mu were longer than this, that's why I'm using exponential distribution, conditioning doesn't do anything. So basically what I know that, for example, if I look on the second vertex which was infected -- so the length of the path from U to the second vertex would be what I saw in the first step plus whatever I will pay in the second step. Like it's exactly it's a good analogy is that once I discover, once the vertex is infected, the length of the shortest path in this model from U to this vertex is exactly the time which path until the infection happened.
Because it's like if you think about Dijkstra, what I'm doing, I'm finding the light test edge from mu. Then I'm subtracting its value from everybody else. That's what conditioning does. Then condition on this as extra value which I'm adding it's now again exponentially distributed. And that's what's happening here.
>>: That's like an exponential of A minus 1 if you want to be performing --
>> Benny Sudakov: That's what -- 1 over minus 1.
>>: Yeah.
>> Benny Sudakov: Okay.
>>: Depends on what you have to do with it. [indiscernible].
>> Benny Sudakov: So now here it's a minimum. Minimum of KN minus K exponential distribution with probability, with expectation 1. And again so what does it mean? Does it mean that -- so that's what extra was added when you go from kakutani plus 1. So the time from K infected vertices to K plus 1 infected. It's again I think -- you want, we can write it like that. But I want to have -- can write 1 over N minus 1 and I can write here. 1 minus K.
Okay. And the total time from the very beginning until -- sorry?
>>: Vertices in set of K vertices, they're in fact different moments of time. So didn't you get an overestimate when you just take a minimum, like here you're assuming that they're all infected?
>> Benny Sudakov: No. Like so I'm looking from the moment the K vertex was infected until K plus 1 vertex was infected.
>>: So you have -- sadly.

>> Benny Sudakov: No, it's a minimum.
>>: But 1 over N minus 1 that's the mean.
>> Benny Sudakov: That's the mean, yes.
>>: But we don't term it as the mean.
[multiple speakers]
>> Benny Sudakov: It doesn't matter. Yeah. Like if you want to think that, if you think about expectation, that's roughly the weight of the first edge 1 over N minus 1. That's roughly --
>>: [indiscernible].
>> Benny Sudakov: Yeah. [laughter].
>> Benny Sudakov: So you're only looking what an extra time you need to wait until the next vertex is infected.
>>: Yeah, but some vertices in this case have been infected a long time ago so they have more chances --
>>: No, lack of memory --
>> Benny Sudakov: That's exactly, lack of memory. If I convert it, by that time none of these edges infections, kind of infection spread.
>>: This was uniform as we started out with -- this is something exponential.
>>: Something exponential time.
>> Benny Sudakov: That's why I said it's much more convenient to think in these terms because it makes it independent. If you think about Dijkstra, it's basically knowing that the distance was already bigger than something if you consider what you're adding is exponential and it's a minimum over all the edges in this cup. So you know that the distance from U to the K vertex which would be uncovered by this algorithm, it's exactly the sum of exponential 1 over I N minus I where I runs from 1 up to time of the K plus 1 I want. K plus 1 to K.
And just to finish explaining from where this log N over N comes. So if I give you -- if you think about your favorite vertex V, it's a given vertex. So you don't know at which step it would be infected. But the step at which any given fixed vertex is infected, it's completely independent, because you know all these variables I could have tossed in advance. So it's completely random variable with probability 1 over N minus 1. So my vertex V can be infected. The second and the third and the fourth and so on and it's all uniform because when I tell you that one of these vertices is infected, it's one vertex at random.

So what it gives is a distance from U to V. It's basically distributed like sum of I equals from 1 up to K. And you see this thing you will -- K only if the vertex V was uncovered after step K plus 1. Because if the vertex V was uncovered before the vertex whose number was before K plus 1, then you're not paying this thing because, as I said, you can kind of think about the whole process of studying this graph.
You first will kind of toss this random variables. You keep them somewhere. And then every time you come to this picture you randomly decide which is the next vertex which get infected. And therefore I have this exponential 1 over IN minus I multiplied by the probability that it was at least K plus 1 vertex further which is N minus 1, N minus K. N minus I here.
>>: If you're interested --
>> Benny Sudakov: If I'm interested in diameter I add all these things. If you do the diameter then you pay factor of 2. It's a typical distance in this graph. Maximal distance, far apart by constant factor. So again --
>>: You need the maximum, the random bits?
>> Benny Sudakov: No, just a second I'll tell you. This is if I fix a given pair, if I fix a given pair, the distance between them distributable like this. And now it's like a probability. So, first of all, the expectation -- and again just to make sure we understand it. This was the price I paid if I uncover my vertex after the step I. And the foreign multiplied probabilities actually happens otherwise this term is not in the sum.
>>: The sum from 1 to N?
>> Benny Sudakov: 1 to N, yes. K was here. Sorry 1 to M because I don't know when this happens. But if you look expectation. So two call logs which we'll get, and this will be important to remember. One corollary is they expected distance between two vertices. You see N minus I and N minus I cancels in expectation. So you get sum of 1 over I you have harmonic sum over N. So it's roughly log N over N.
And the second thing is that you can compute using this -- this is a distribution. Now you can gain a lot of information about this variable. The variance of this distance, which again would be important for us because occasionally we will need to make some claims. We're studying average behavior. It's constant divided by N squared.
You can actually do it precisely, but we're not interested. Because precisely will not mean much here because I will talk about uniform and it would not be the same expression. Okay.
Now, once you have all these things -- for example -- and again you can prove large deviation inequality. Since you know this distribution in particular you can show that probabilities there is a pair of vertices such as the distance between them is, I don't know, five times log N over log N is already so small I can take union over all pairs and it still [indiscernible] to 0. But these are two important things.

This is a very useful fact which tells us that basically every age whose weight is much bigger than log N over N I can discard. There would be no such legs, shortest path in my graph. Leaves me with N log N edges. If I put my M log N, it immediately tells me that in this random model all-pairs shortest path I can compute the time N log N. Any questions?
>>: So in this case the probability that you failed at even 1 minus exponential in it? Or is it just --
>> Benny Sudakov: N to the epsilon, because I don't think this is so concentrated.
Exponential in log N.
>>: How do you derive that [indiscernible] you would need to consider N log N.
>> Benny Sudakov: Because you see this thing would be concentrated. So, again, if I ask you what's the probability that some length is five times log N over N, then this is already much smaller than 1 over N squared. I drop these edges and round N log N edges left.
So the problem which was posed about 20 years ago by Freeze and McDermitt
[phonetic] in the survey on algorithmic problem in the random graph models, it was the following. Find algorithm which runs in time little O of N squared log N. So just improve over this easy kind of observation that you can discard very heavy edges.
And the theorem I want to present today exist algorithm with time constant N squared.
This abbreviation stands with high probability, which means with probability tending to one as one tends to infinity. Time is constant N squared, so it's as good as it can get because you need an output in N squared numbers, you need to tell me what are the distances.
Okay. So any questions? So in the remaining time, I'll sketch you what the algorithm does. Actually, it's relatively simple. So I can tell you most of the details. So we will need two steps. So the first step is algorithm which not all algorithms -- it's a very nice algorithm which was developed by Demetrescue [phonetic] and Italiano [phonetic]. And what they noticed is that in order to compute all-pairs shortest path, one important notion is locally shortest path. So let me give you this notion.
Okay. So just one agreement about notation. When I draw the straight line I mean really an edge, and when I draw the squiggly line, it means a path. So this always will mean an edge and this will always mean a path.
So if you have a path like that, it's called walk always shortest path.
If both these two paths, shortest paths. Okay? It's very easy. If you remove the first edge or remove the last edge, what's left is the shortest path. So that's a definition of locally shortest path. Now, the algorithm with which they presented, what it does it actually computes locally shortest path, compute shortest path in graph by only looking at shortest path and locally shortest path.
>>: The locally shortest path does not need to be the shortest path?

>> Benny Sudakov: Does not need to be the shortest path, yes, absolutely.
Let me tell you the algorithm and I will tell you, I'll write there algorithm. And let me write first just what parameters we maintain during the algorithm. So during the algorithm we will maintain the following thing. For any pair of vertices we will remember second vertex on path from U to V. Then we'll remember vertex before last from U to V. And there are two more things. So imagine owe what is LUV, all vertex X such that X is the shortest path.
And similarly here, it's all vertices Y such that -- so basically doing this algorithm, these are just things so that you will be able to see that I'm not cheating and indeed maintaining the parameters takes constant time. I will remember for every path which
I'm computing what is the second vertex on the path, one vertex before the last, and also for every pair of vertices I will have at least which says what the vertices if I add to this path it's still shortest from the left and from the right.
>>: [indiscernible] path.
>> Benny Sudakov: Yes, UV of course would be the shortest path.
>>: In that definition do you have to remember what the wiggly path it needs to be in?
>> Benny Sudakov: No, just remember this list. In the beginning the LUV and RUV will be empty, because in the beginning we have no shortest paths. But once something will become shortest path I will update this list.
>>: The definition of L is it's X such that if the wiggly line is the shortest path --
>> Benny Sudakov: Absolutely. It's included in the definition because if this is the shortest path, then the wiggly line is the shortest path as well. Because shortest path of shortest path.
But here is the algorithm. Just want to write you to motivate why we will in the second step will look on the shortest path. So here's an algorithm on the locally shortest path.
So the algorithm has the following steps. So in the beginning you set distances between
U and V is just the weight between you and V. You put all PSUV into Q with key exactly this distance. And then at every step you do extract UV with minimal key. So one thing you approve every time you extract the path it's minimal path.
Now you need to do some updates. Now this locally shortest path coming to the game.
So what you'll do is suppose this was your path. So suppose this is what you extract.
Now, you do the following. For U prime, okay, so for every X such that XU prime V prime was shortest path. Sorry. V. Now, you look on this path. So this path is a sub path of the path of UV. It's also shortest. It's really strictly shorter than the path from U to V. It means you extracted it earlier. Everything which is short again you prove that whatever I describe is this algorithm has this property. You extract it earlier.
So you already have this guy. Now, if you had this guy, then in particular for U prime you had all the edges, all the vertices X which you can add to U prime such that this path is such that this path is shortest.

Shortest path. So path from U prime to V. Now you check what are the Xs this is still the shortest path. And what you do is the following. So you compare.
So basically, so let me say it again. So you put all the paths in the queue. Then at some point you extract the shortest path. And then you check, once you extract the shortest path, you check. Did I write it correctly? No, I didn't write it correctly. So let me --
So let me say it again. So just I'll make this clear. So you extracted the path UV. Then any sub path of this path is the shortest path. So look on the path from UV to prime. It's the shortest path. Now, you can look on all the guys that you can add to U such that XU,
UV prime is still the shortest path. Look on one such. This is a very long path from X to
V now not necessarily shortest, just second. What you know, you know that this path is shortest and you know that this path is shortest because that's how you choose X. So this whole picture is a locally shortest path.
And now what you do, you take this locally shortest path and you check, is it indeed shortest or not. And so you compare it what is written in your table for X, the distance between X and V.
If you did this new path is shorter, then you decrease the key, otherwise you do nothing.
So it may be complicated --
>>: Shortest what you currently know.
>> Benny Sudakov: What you currently know.
>>: Locally.
>> Benny Sudakov: It's not local. So the only thing when you know the things are shortest when you extract. So again so just let me say it. At some point you come you take it from queue the next path. Then you're proven this algorithm whenever you took it out it's indeed the shortest path in the graph. Moreover, you do the following. Here is the shortest path which you know. You take, for example, beginning of this path except the last vertex. It's also shortest because it's a sub path of shortest path, and you add one vertex from the list -- so X would be the least left of UV prime. So you add this vertex X such that you know that X to V prime is also shortest path.
>>: With respect to what we currently know.
>> Benny Sudakov: No, with respect to what we currently know. Then you look on the whole picture. The whole picture you don't know this is the shortest path. You know from X to V prime you're shortest and you know from U to V you're shortest. What you got is exactly locally shortest path in my definition.
And the only thing you do, you check is this locally shortest path the best data you have for distance between X and V and if it is, then you update the key and otherwise you do nothing.
>>: So locally shortest path are like global or in a sense does it depend on information you have to know or it's --

>> Benny Sudakov: No, when I tell you that something is locally shortest path it's global information, because again know that I will put only data into LUV and RUV only when I for sure know that some path is shortest. Only when I extract the path from the queue and I know it's the shortest I update the list.
For example, let me tell you what next thing you do in the last. You update the following list. So you update the left list of U prime V, and you update the right list of UV prime adding this path to it only now.
So if you look on the path from U prime to V, you know that you can add U and still be shortest. Only now you're putting this longer path into this list. And only now you're putting this longer path into the list. Whenever you put in the list L and R, it's only two things. It's only passes which you really know that they're shortest.
>>: Locally?
>> Benny Sudakov: No, shortest. So, again, so for every pair of vertices I will -- I will have the list which says I can extend left and still be shortest and I extend right and still be shortest. This would be really genuine shortest path. I put something there only something if I know it for sure. For example, this case, once I extracted path UV, I know for sure if I to pass U prime V, it's still shortest. Only then do I put it into this LU prime V and here I put it in the path RUV prime.
So again is it clear? So you do the following. Don't worry, it's 15 minutes I will say what.
I extract the shortest path. I try extend it left. I try extend it right. I get locally shortest path. I compare what is currently in the database and if this thing is shorter I recover it and otherwise I don't ask.
So now what you can see in and this would be important, so basically what I'm doing and the sum of the sizes of this list during this algorithm -- and that's what the main time which this algorithm takes it's the exactly the number of locally shortest path up to a constant because everything else cost me constant time plus extract min. There are two things. Extract minimum from the queue and update time. And before I need to tell you two things, too. Kind of finish the proof. One, Y is the number locally. So there are two claims. The most important things, the number of locally shortest path is constant N squared. So if I can show you that the number of locally shortest path is constant N squared at least you know that all this update operation I did in constant N square. Now, why I can extract mean very efficiently, because I will not maintain my keys in the
[indiscernible] natural heap I'll just maintain them as a bucket. I will sort them as a bucket because know that one remark, the length of the shortest path is roughly log N over N.
The lightest edgy can show that it's, with overwhelming probability bigger than 1 over N squared log N. And therefore if I do the buckets, if I kind of always keep my path as a bucket where the width of the bucket would be exactly 1 over N squared log N, then what I will know I will know that two paths which are inside the same bucket, they differ by a number which is big, which is smaller than the length of the lightest edge. And therefore when I extract min it really doesn't care which of them to took. If you have two paths whose difference is less than the lightest than the graph it really doesn't matter

which of hem to take. So it's one observation which actually people used a lot in this minimal shortest path business.
And the number of such buckets is at most N times log squared, just because if you divide these two numbers you'll get -- and they extract min operation will not cost me even N squared. I will kind of very easily not spending time here. So the main thing which I'll get is a number of locally shortest paths N squared.
So to prove this claim -- and that's exactly I have ten minutes to sketch it to you, so I'll show you that the probability -- so some path is the locally shortest path, is 1 over N squared. And since there are roughly N to the four options like that, that's the locally shortest path. There's the stage and then there's the last edge and you know AC is the shortest and BD is the shortest. So for I specified four vertices, N to the four options to specify these four vertices. I'll show you the probabilities at any given configuration like this. So if you take vertices A and B, then after B you take shortest path to C. And after
C you take the H to B. If probability is that this doesn't matter what happens in between.
Locally shortest path, the probability of this is smaller than 1 over N square to the four options I get expected number. And I so far will show you only expected number constant N squared.
And now I may be cheating because, for example, they might be locally shortest path which looks like A, B, C where AB is shortest set and BC is the shortest set and those are very easy to handle because then AB should be very like H, lighter than log N over
N, and this should be light H and altogether it's log squared, why squared are very small probabilities of this path is locally short. So easy to [indiscernible].
Okay. So let me basically tell you why this is so. So suppose you know that this thing is locally shortest. Then you have the following equalities. So the distance from the weight of the edge from A to B plus distance from B to C equals distance from A to C. Because this should be shortest path. And similarly the distance from B to C plus the weight of the edge from C to D, it should be the distance from B to B.
That's definitely the case. Now let me introduce the following notation. DXYZ is distance from Y to Z if we delete X.
So I would delete some of the vertices from my graph and look what is the distance in the remaining graph. And here some simple observation to make. So what is the simple observation which I want to make? I want to first say that the distance from B to C remains the same even if I delete vertex A or even if I delete vertex D.
Why? Because you see AC was the shortest path. If A was on the path from B to C then of course ABC was not the shortest path. And similarly B to D was the shortest path. If D was here, then of course BCD was not the shortest path. So I know that these guys, if this happened to be conditioning that this is indeed locally shortest path and therefore A, C, B are really shortest path, then I know if I delete A, the distance from
B and C doesn't change than if I delete D. And obviously to my inequalities which I write the distance of A to C is, of course, at most the distance from A to C if I delete B.
Because when I delete some vertex as a number of possibilities to hold my path. And similarly distance from B to D less or equals distance from B to D, if I athlete C.
>>: Delete B then the distance --

>> Benny Sudakov: Only goes. Even don't pay attention that it's B. Just delete any vertex in the graph, the distance between the remaining vertices can only go up, cannot go down. And what I'm saying something not related to anything, yeah. Any graph, except [indiscernible]. Let's rewrite this inequalities and look on when the event starts.
So I claim if this path was locally shortest path, then the following events start to happen.
So distance, the weight of the edge between AB is less or equal. And the weight of the edge CD is less or equal BD here. Let's see. So why I just substituted this with A and here I put B and I just subtract and I use these inequalities.
So why this is an interesting inequality? So know that I'm not saying it's equivalent. But
I'm saying definitely if this is locally shortest path, this should happen, because now I can toss all the coins for all the edges except the edge ABCD and I already determine all these quantities here. So if you already tell me all the weights of the edges in the graph except what happened with HABCD this part is determined and this part is not.
So if I call -- let me call X to be the distance from A to C and Y to be the distance from B to D when you delete C and Z to be the distance from BC know that these two things, the uniform random variable. Independent of what happened here. So again put all the weights of the edges except the edges between A, B and CD. You get two numbers and you need to get these inequalities. So what I'll get is I'll get the probability my star event is less or equal than expectation of X minus Z absolute value times Y minus Z absolute value.
Because the weight of this is X.
>>: It's distance from B to C mixed with D -- just for symmetry?
>>: What you subtract is BC --
>> Benny Sudakov: I'm subtracting this.
>>: And it's the same but it should be sub D.
>> Benny Sudakov: But I can subtract whatever I want.
>>: Yeah.
>> Benny Sudakov: It's the same thing. The same random variable. Now what the important thing here, so you have the expectation of this. So now let me just briefly write you from where the bound comes. So here these two random variables you have a product so you can write [indiscernible] and bound this by expectation of X minus Z squared one-half plus one-half expectation of Y minus Z squared.
But what important to note XYZ this is the same random variables. It's just the distance between two points in random graph was random edges weights edges and N minus 1 vertices. So these are the distances in KN minus 1 with random edges.
>>: I mean, it doesn't mention it, but I think ABC could be sub D.
>> Benny Sudakov: B.
>>: Because you want C, edge CD not D there.

>> Benny Sudakov: Yeah. They're all equal. So [indiscernible] doesn't matter. But that's why I'm saying so this and this is Z.
So now one last thing just to finish here. So know that X minus Z squared I can write X minus mu minus Z, minus mu squared when mu is just expectation of X, which also happens to equal expectation of Z, because this is the same random variable. That's the important thing, which is all random variables I got is just the distance between two points in N minus 1 vertex graph where the weights are uniform.
And now if you write Quashy Schwartz [phonetic] again know that every such term is exactly the variance. X minus expectation of X squared, the expectation of this is a variance. Z minus expectation of this square expectation of this is a variance. So what you will get, you will get constant times the variance of this random variable which I discuss in the very beginning. The distance between two points. And the variance of distance between two points we said it's exactly constant over N squared. So you got all these things gives you the probability of this event start is at most some constant over N squared, because just constant time number of variances of the distance between two points. And that's basically what I wanted to tell you today.
>>: Why high probability --
>> Benny Sudakov: No. I think I'll stop without saying why with high probability. So let's understand what I just said so far.
>>: Could you tell us how high the high probability is?
>> Benny Sudakov: You can make it I think to epsilon.
>>: One minus N to the minus epsilon?
>> Benny Sudakov: Yes. But I think this is the nicest part and the nicest part is that you can by somehow deleting vertices kill all the correlations. So by deleting certain vertices you become, you get here three random variables which look exactly the same and therefore you can reduce everything to the variance of these random variables. That's it.
[applause]
>>: Yuval Peres: Questions before we go to the wine?
>>: What other random graph models, it seems [indiscernible].
>> Benny Sudakov: So one interesting graph model which we kind of still thinking especially if it's sparse, if you just take usual random graph where the randomness comes from edges, some edges in, some edges out, but the way to think about just 01 if the edge is in, the weight is, sorry, if the edge is in, the weight is 1. If edge is not there, it's infinity, not 01, but 1 infinity.
If you take very sparse such graph, then somehow we don't -- it's not clear how this analysis -- especially I didn't mention it. But let me say that for the algorithm of
Demetriesque Italiano is very important that the minimal, shortest path between any pair of vertex is unique, somehow shortest path it will come up in the algorithm. In this random weight model, it's very easy that every weight appears exactly. So the shortest path is unique. But as soon as you get to one infinity weights you might have many shortest paths.

>>: One comment that's much of the -- you couldn't talk about this, go from -- this gives you the expected number of paths N squared so the probability it's more than
[indiscernible] constant but doesn't tell you that this probability going to 1 which is bounded by constant N squared. And that requires a lot more work.
>> Benny Sudakov: Exactly. That's why you cannot do that in a one hour talk.
>> Yuval Peres: Let's thank the speaker again.
[applause]