>> Eyal Lubetzky: Hi, everyone. It's a pleasure to host Benny Sudakov who's visiting us almost
every year from UCLA. And Benny will be talking about a new simple proof for the classical
phase transition in the Erdos and Renyi random graph.
>> Benny Sudakov: Thank you, Eyal. Let me say that first what I'm going to talk about is a
joint work with Michael Krivelevich, and in this the idea would be to present an approach which
we think is pretty simple approach to several classical result in random graphs.
Since we're talking about random graphs, let me start with a basic definition. So the model we
are looking at is G(n, p). It's a probability space on graphs on N vertices in which probabilities
of IJ is an edge is P which can depend on N, and this is randomly and independently for all
possible pairs of edges.
And another piece of notation, so this is 1, this is 2, so given a property, graph property P, we
will say that G(n, p) has P with high probability, it stands with high probability.
If probability that G(n, p) satisfies P, times to 1 as [inaudible]. We will have always asymptotic
notation. Okay.
So this is our basic object. So this area, the area of starting with probabilities of random graphs
goes back 50 years to the work of Erdos and Renyi. And one of the first result Erdos and Renyi
proved was theorem of Erdos and Renyi as if you look on the edge probability P around 1 over
N, when you process the -- the properties of random graph experience a very interesting behavior
so called, you know, once you move from less than 1 over N to above 1 over N, suddenly the
giant component emerges.
So we will have two regimes. So in the regime when your edge probability is a little bit below 1
over N, we have with high probability all connected components have size bigger of log N, and I
put here epsilon, indicating that the constant depends on epsilon. And when P is 1 plus epsilon
N, then with high probability there is a component of linear size.
Let me say that this is one of the probability most well-known result in modeling random graph,
but in the whole probabilistic combinatorics, and obviously since what [inaudible] Erdos and
Renyi it was revisited many time and extended and people understand it very well so they know
precisely what is the size of the component here and here, they know what's going on if you, you
know, slow down and kind of see what happening in the threshold window, how you move from
1 minus epsilon to 1 plus epsilon, lots of information is known. Okay.
This is one result I want to talk about. Another result is a theorem by [inaudible]. So they wrote
in '80s. It also very old result. A paper which appeared actually in a celebrated first issue. It
was first paper in the first issue of Combinatorica. They answered the question of Erdos and
proved that not only you have a giant component but actually you have a long path, a long cycle,
both of linear size.
So what they prove, that if your edge probability is 1 plus epsilon divided by N, then with high
probability G(n, p) contains path. And actually can show once you have path also cycle of linear
links. Okay.
And so what I want to --
>>: [inaudible].
>> Benny Sudakov: Sorry?
>>: [inaudible] or just ->> Benny Sudakov: No, no. No, nothing here. Just the fact that you, you know, your joint
component can be real complicated [inaudible] mostly three-leg structure, here actually talking
about a path, which is harder to get.
So this is the second result. And what I want to do in this talk, I want to show you an approach
which actually gives both of these results. And I think it's pretty elementary. And because of its
elementary, it works in some other circumstances, and I will mention in which circumstances it
works.
So just to be precise in terms of formulas, here's the results -- here is the statements which I
will -- going to prove claims. Okay.
So, again, in the regime, when P is 1 minus epsilon over N, using this approach, you can prove
that with high probability in G(n, p) all connected components have size at most -- and I eel
write precise numbers because I want to say something about these numbers -- at most 7 over
epsilon square log N.
And then the next thing, if P equals 1 plus epsilon over N, then with high probability G(n, p) has
a component. I'll stop writing connected components. It's obvious what I mean. Has a
component of size at least epsilon N over 2.
And the third thing is that if P is 1 plus epsilon over N, then again with high probability G(n, p)
has path/cycle of length at least epsilon square N over phi. Okay. So that's the results which
easily follow from this approach, which I will present.
Now, why I'm writing a precise formula is because what I want to say, that in addition to giving
simple proofs for the qualitative statements, surprisingly this approach also don't recover
completely the precise constant, it recovers at least a correct dependence on the epsilon. So
indeed the best dependence on the epsilon in this regime is log N with a constant -- log N with a
coefficient 1 over epsilon square. And then this regime giant component behaves like constant
epsilon N. And indeed the length of the longest cycle is of order epsilon square N because ->>: But the log should be log over epsilon cubed N.
>> Benny Sudakov: Sorry?
>>: Not log N, but log over epsilon cubed N, otherwise you're doing an extra log in the
[inaudible].
>> Benny Sudakov: That's true. So that's -- I need careful what -- if epsilon is constant, there's
at least -- but small it's recover [inaudible]. Another thing which I want to mention, which is
kind of more interesting in this regime, and you'll see from the proof, it works not only for
epsilon constant, but, you know, if you know a little bit more about the topic, you know that the
critical regime where -- where things happen is when you take epsilon N to the power minus 1
[inaudible]. So this all [inaudible] when epsilon is N to the power minus 1 [inaudible] let's say
types square root log.
So all these results still continue to work.
So it's kind of interesting. So it's -- as I said, the new thing is each of the proofs are simple, and I
think it's a bit different compared to other proofs which people used. And they give you a lot of
things pretty cheaply. Okay?
So that's what I'm trying to present. So now what we are going to do, another nice thing about
this approach, we are going to use some very, very basic tools, the tools which probably you
teach in a class of algorithms the first year for the students in computer science.
So the algorithm which I'm going to use is a graph exploration algorithm called depth-first
search.
So of course most of you know, but just to be on the safe side, let me briefly describe the
algorithm and let me briefly tell you what are the properties of the algorithm which I'm going to
use. Okay?
So this is graph exploration algorithm. So you start with a graph. Okay. And you explore it,
basically discovering connected components, but in certain way. So you fix some ordering of
the vertices. So [inaudible] fixed ordering in which you explore the graph. And at any moment
you have a partition of the vertex that's into three sets, S plus U plus T. Okay? It's three
disjoined sets where S is a set of already explored vertices, T is a set of yet not discovered
vertices, and U is a set of vertices which you're currently exploring.
And the exploration. And it's important how we're handling this U. So U is a stack, so it's a list.
So they kept in stack last inferred stop. Okay. So this means that every time you add vertex to U
you put it in the end; every time you remove vertex from U you take the vertex from the end and
you remove it. Okay? So you is -- always will be this linear list, where the vertex we're always
adding to the N and we're removing it also from this N. Okay?
Now, how this algorithm works, so here is the brief description. You start with U empty. And in
the end -- in -- so it was U empty, S empty, and T, everything. And in the end S is everything
and U and T are empty, so you basically explore the whole graph. And at each round you do the
following. If your U is not empty, so if you have vertex in -- so if you have vertices in your list,
then look on V, which is last vertex in U. If there is a W, if there is a neighbor of V call it W
empty, add first such neighbor to U.
So you remember all my vertices are ordered. So if there are more than one neighbor of V,
which I currently didn't discover, just pick the first one and add it to U. So, remember, what
does [inaudible] put it to the end of the list.
Otherwise, what means otherwise? It means that V has no neighbors which we didn't discover
yet. It's all neighbors of V we already see. Otherwise, move V to S and continue. Okay?
And the last thing which I need to tell you, that if at some point U becomes empty, empty, pick
first vertex from T and move it to U. Okay? So that's the algorithm.
So you basically took the last vertex on which you look, which you discovered, and you're trying
to discover its neighbor. If there is no new neighbors, you said, okay, already completely
explore this vertex, I move it S, if at some point my stack become empty, start with [inaudible] in
your vertex and continue doing it.
Okay. So very basic algorithm. Again, I just want to make sure that it's written on the
blackboard so you can look at it, because everything would be self-contained. There are four
properties of this algorithm which I'm going to use, four very basic properties. The first one
which from definition clear, each round one vertex moves from T to U or from U to S.
So why this is important? Things are continuous. At any point I can stop and say, okay, I want
my S to be of certain size, I can stop my algorithm at that moment. So things changing from the
point of your sizes continuously.
Now, another important thing is U always forms path in G. So because the way we build U, it's
always a path. Okay. So whatever is in U, it gives us a path.
The third thing is no edges from S to T. Obviously. Whenever we move vertex to S from U, it
means we already explore its neighbors or no neighbors of this vertex left in T, so there were no
edges from S to T at any given moment in the algorithm.
And the lesson which I need is the following. Between two times when U is empty, we're
exploring same connected component of T. Because once we start exploring the connected
components, once we touch a connected component, we continue to explore this connected
component. The fact that U becomes empty again means we finish exploring. There are no
edges going out in any direction. Yes? So any two moments between which U is not empty, this
gives us the whole connected component. This would be also useful.
Is this clear? These are four properties I'm going to use. Okay? That's -- that's all.
Now let me -- let me show you -- show you the proof of, let's say [inaudible]. And I mentioned
something about the large connected component and so on.
So how I'm going to -- kind of I'm going to use DFS on the random graph in the way, in this
case, we are not very original, everybody does it, so there's a way you kind of use any graph
exploration algorithm in a random graph. You generate random graph on the fly.
What I'll do, I'll take -- okay, so now this is my model -- so take my big N to be [inaudible] these
are coin flips for the edges. I'll look on the sequence of random variables X, XI, I runs from 1 up
to N, and XI is [inaudible] random variable 1 with probability P and 0 otherwise. Okay?
And I generate G(n, p) by feeding the sequence X to DFS. What it means? DFS, let's say, with
order 1, 2, and so on. Yes. I said DFS should fix some other [inaudible] fix order 1 up to N. So
what does it mean? So you start running DFS, and every time DFS wants to ask as an edge, you
just take your next coin flip from the consequence, the one which you just didn't solve, and based
on this coin flip you tell me the edge there or not. Okay?
So obviously generate a random graph, and the only thing what I want to do, I want to analyze
what happens with this algorithm.
And now another nice thing is that although we're talking about things which kind of may be
complicated from probability point of view, the only probabilistic -- I mean, of course there
should be some statement, probabilistic statement here. The only statement we're going to use,
at least for the path, it's more or less something like Chebyshev's inequality.
So here is the only property of the sequence I'm going to use. Everything else would be
deterministic. So here is the property which I'm going to use. So I fix my P1 plus epsilon over
N. I fix N0, which would be epsilon N square over 2. And I look how many 1s I see in the
sequence from the beginning up to the moment N0.
When I'm looking, I'm looking on sum of XI. I runs from 1 up to N0. These are binomial
random variable, so obviously this thing is concentrated, concentrated around its expectation, so
its expectation is epsilon 1 plus epsilon. N over 2 is just probability times this number.
And the only thing I want, I want with high probability this is at most let's say L, where the only
thing which I need about L, that it's omega, something timing to infinity of let's multiply this
number. It's a square root of epsilon N. Yes?
So, again, this is a most basic result you can imagine because what? These are some inspect
random variables, so here is a proof. So the variance of sum of XI, I runs from 1 up to N0 is up
to a constant epsilon N because it's, you know, N0 times P times 1 minus P, so it's epsilon N.
And by Chebyshev inequality probability to deviate by more than square root of the variance is
just 1 over the square of this number by which you deviate. If I take this omega. Omega means
this L divided by square root epsilon N times to infinity. It means that probability of this -- this
is pending to 0.
So that's the only thing I'm going to use. Any questions so far? Okay.
So now -- now basically what I'm going to do, I'm going to take this algorithm, going to take this
set, and show you that with high probability in the random graph G(n, p) with edge probability
P1 plus epsilon I expect to see paths of lengths epsilon square N over 5.
Okay. So here is the proof of the result. Okay? So, again, let me recall you claim, claim is with
high probability G(n, p), P equals 1 plus epsilon over N, contains paths of length at least epsilon
square over 5. And then getting cycle from paths would be easy. Okay?
So here is a proof. So run DFS on G, yes, some -- to make it short, G(n, p) I write on G for N0
steps. N0 steps mean you -- N0 steps means U until you see N0 pairs. Okay? So you're
basically asking zero questions. So you run your process, generating on the fly random graph for
N0 steps, and then you stop and you analyze what's going to happen. Okay?
So the first thing you say, if at any moment your U -- yes? You remember you have this vertices
instead which form paths is -- ever is big, bigger than epsilon square N over 5, you're done. If
ever U is at least epsilon square and over 5, done. So assume U is smaller than epsilon square N
over 5 during the whole process. That's the first thing.
Now, the second thing I want to persuade you is that you're far from seeing the whole graph and
time N0. So your S, the set of already explored vertices, is really small. And small I don't need
very small. So we claim that my S is at most N over 3. Okay?
Why? At time S, again, at time N0. So suppose not. Okay? So remember now I'm using the
fact that the process is continuous from the point of U size of S. So I can stop the process at time
when S is precisely N over 3. Okay?
Now let's look how big is T. Then my T has size N minus S minus U. Obviously at least 10
over 3. Because U is small. Think about epsilon small constant [inaudible].
So U is tiny. So S is at most N over 3 and T is big. So then we checked all pairs from S to T,
which is S times T at least N square over 9, much, much bigger than N0 contradiction.
So let me stop for a second here, because that would be the main thing I'm going to use. So,
remember, when we stop at time N0, we only look on N0 pairs. Only N0 pairs of the graphs
were checked whether they're edges or not. So if at that time my S reach size N over 3 and my T
is of size also bigger than N over 3, it means that, remember what algorithm said, there are no
edges from S to T. No edges means I check all these pairs and I discover they are all nonedges.
So if that's the situation, then already at that time I looked on N square over 9 pairs, which is
impossible because I stopped my process at the time N0. Okay?
So that's the main tool which I'm going to use; that, you know, I cannot look in too many edges.
If the structure of my graph is so that the corollary I looked in too many edges, that's a
contradiction. That's the only thing I'm going to use. So this implies that S small is an N over 3.
Okay. So now the -- now kind of the finishing touch. Oh. So now I'm again trying to get a
contradiction, and if I get a contradiction, contradiction to what it's going to be, it would be
contradiction that my U was always small. So I'm still going to show in the end that I'm getting a
contradiction.
Now, what I have in the beginning of this stage, I know already that my S is of size N over 3.
And I know already that my U is of size at most epsilon square N over 5, and therefore I know
that my T is not empty. Okay?
Moreover, I know that each XI equals 1 increases S plus U by 1. Every time you discover an
edge, you move it to U. Maybe later you move this vertex to U in the neighbor. Every time you
discover a new neighbor, you move this neighbor to U. Maybe eventually this neighbor moves
to S. But definitely every time XI equals 1 it means the new edge comes, you discover new
vertex. And this vertex increase the size of S union U.
Is this clear? Because, you know, what are the edges? What are the real edges in which you
looked? You're never looking on the edges inside S or from U to S. You're always looking on
the edges from U to T. So every time such edge is discovered, it's a new vertex which added to
the stack and then eventually maybe this vertex end up in S, but it increases the size of S union
U.
So therefore the number of XI is -- which were 1, and this Y needs this inequality, basically tells
me what is the size of S union U at the time N0. This is precisely the number 1s which I saw.
So this implies -- so S union -- let me put plus because union looks like U as well. So S plus U
size is at least as big as epsilon 1 plus epsilon divided over 2N minus this L. Okay?
And since U was less than epsilon square N over 5, I'll get importantly that S is at least as big as
epsilon 1 plus epsilon over 2N minus epsilon square N over 5 minus [inaudible].
Any questions? And now -- now it would be exactly the same computation. Now, the way I'm
going to get contradiction, I again will just compute how many pairs are with one vertex in S and
one vertex in T, and I'll show you that I saw too many pairs. I look in too many pairs compared
to what I will already promise you with the number N0. Okay?
So let's -- let's look continue computation, okay? So if this is my situation, then number of pairs
with one vertex in S and another in T is -- so we know that this is at most -- this is S times T, but
it's at most N0 because N0 was the total number of pairs about which I ask questions. And
definitely about all the eight pairs which have one vertex and one vertex in T, I ask question and
get the answer knowledge. Okay. So I know that the product of these two sizes should be at
most N0.
Now, it's equals S times N minus S minus U. Okay? This is bigger report. So let's first
substitute U. So it's S times N minus S minus epsilon square N over 5. Yes? Trying to do it
slowly to see that I'm not cheating you and not switching the inequalities because we can prove
remarkable things if you some point switch -- yes, I'm substituting a bigger number for you, so
definitely it's still inequality.
And now this is a kosher moment. Look on this function. Because that's why I needed to show
you that S is smaller than N over 3, so up to basically roughly N over 2 this function is
increasing function of S. So therefore to take its minimum, I will substitute the smallest possible
value of S. So that's important to notice. Yes? So I'm substituting because this function is
increasing and my S is smaller than N over 3, I'm substituting the smallest value of S.
So what is the smallest value of S? It's epsilon times 1 plus epsilon over 2N minus epsilon
square N over 5 minus [inaudible]. And now if I'll substitute it here, then I'll get N minus
epsilon ->>: [inaudible].
>> Benny Sudakov: Well, 2. Yes. Sorry. 2 here and N here. Yes. Epsilon 1 plus epsilon over
2N. Epsilon square over 5. Epsilon square over 5 cancels plus.
And now let me tell you what every single thing here is, so this equals. So let me see what I
have here. I have here epsilon N over 2. Now let's look what happens with epsilon square. So
here I will have epsilon square over 2, which is 5 epsilon square over 10 minus 2 epsilon square
over 10, so I have plus 3/10 epsilon square N minus L. And here I will have N minus epsilon N
over 2 minus epsilon square N over 2 plus L. Okay?
And now let's look. So epsilon N over 2 times N. This is a main term. It's epsilon N square
over 2. So so far it's good. This is this guy.
And now the important things would be to look on the epsilon square. So here I have plus 3/10
minus a quarter. So 3/10 is 6 over 20, quarter is 5 over 20, so I have here epsilon square N
square over 20. Okay?
And that's really what will get my contradiction, because everything else is -- so you also have
some constant of order epsilon cube N square, and you also have some constant of the order L
times N. All right?
So that's all. That's all numbers. And now what I claim, as long as this number bigger than these
numbers, you get a contradiction, so you proved your result. And now why -- why keep L to the
very end? Because you can check that if epsilon is bigger than N to the 1 minus [inaudible] this
number beats this number.
Obviously if you only care about constant epsilon, then you can take L to be any function. You
can take L to be N to the 2/3, but I claim that you can actually check, yeah, so this you
remember. This is -- thing is epsilon power half N to the power three halves, and if epsilon is N
to the minus 1 [inaudible] this is exactly N to the 4 [inaudible] and this is exactly N to the 4
[inaudible]. So if you move it a little bit [inaudible].
Well, that's the [inaudible]. Okay? Any questions?
So, as I said, the proof is really -- once you have this statement, it's very deterministic, so you're
basically getting a contradiction on the fact that a U is small. So you look -- you just look on too
many nonedges. Okay?
Now -- now let me say something about -- okay. So this is kind of maybe more easily believable
because, you know, if I'm looking for a long path, then my U is indeed by definition of DFS is a
path, so they fall -- it's kind of easy to believe that I'm getting large U.
So now I want to tell you a few words about why this also works for giant component. But
before I do this, let me only just say a few words about how you're getting cycle from the paths.
Again, probably most of you know, but just one remark.
So now to get the cycle from the path, you already got your path of size epsilon square N over 5.
So what you can do, you can take N to the 2/3 vertices in the beginning, let's say 2/3 [inaudible]
N vertices [inaudible]. So if you get me an edge from here to here, you get a cycle. Okay?
But this gives you N to the 4/3 pairs. So in order to get one edge in this interval, you need to
sprinkle probability, you know, P prime, let's say, 1 over N to the 7/6. So this will not affect
anything, and you get a cycle. Because this is much smaller than 1 over in, so your probability
virtually remains 1 plus epsilon over N. But now once you found this edge, found this path, you
will also find the cycle. So cycle you're getting for the same price as a path.
So now one word about component. So let me remove this. So for the component you need to
do a little bit more work. So instead of Chebyshev, Chebyshev already will not enough, or least
for follow approach. So you need a little bit more. You need Chebyshev bound. Because
instead of talking about that for one value, N0, I want to claim that this proposition halts for all T
between, I don't know, some theta N square, and epsilon N square over 2.
So it doesn't matter. You can put here anything you want. But you want to say that there would
be a very long interval during which your U will never become empty, because you remember
how you're showing me that there is a large component. If you find me a long interval of time
during which U was never empty, it means during this time it was exploring the same
component.
So if you start with something really, really small and you end up here and you show me that
during this time U was never empty, then you're exploring the same component. And what is the
size of the component? The size of the component is the number of 1s you see. Remember, it's
a number once you see during this time. And the number was is epsilon and square what 2 times
P, which is roughly epsilon N over 2. So that's how you get it.
So what I want to show, I want to show that P again is 1 plus epsilon over N, T is this, and I want
to show that sum of XI, I runs from 1 up to T minus 1 plus epsilon over NT less or equal what it
should be, square root of epsilon T over N omega.
So I want to show that this happens all the time. So basically you will round your value. And of
course omega is now not enough, so what I instead of do I'll multiply this by let's say square root
log N with some constant. And now I can use a large deviation inequality, so again binomial
distribution, probabilities that it deviates by square root of variance times square root log N. It's
small as in power of N, so I can indeed take a union bound.
Now, once I do this, the proof would be exactly the same. Because how I'll show you, so now
the claim would be, claim during times from, you know, any constant N square till epsilon N
square over 2, U never empty. Okay?
And why U never empty? It's exactly this computation. It's even easier than that, because now I
even don't notice [inaudible] there would be this no error term epsilon N square over 5. If U is
empty, then everything is in S and it means that you know precisely what is the size of the S,
because the number -- the size of the S is the number once you saw during this time, it's roughly
the time times P, and now you're comparing S times T where basically S times N minus S with
the number -- with a T, with how long you run the process. And the same contradiction. So
basically the precise does the same proofs.
And, again, if you carefully check error terms, it works up to N to the power 1 minus. Okay?
So that's all the ideas. And similarly you can show that in subcritical regime you don't have giant
component exactly the same way as before but now you show that it cannot be long interval
where every time you see some 1s. So at some point you will become empty, after some
constant log N steps, U becomes empty and then empty again and then empty again, and again
the same computation. Okay? So that's all the idea.
Now, the thing says it's very similar to the proofs people did. Seeing what simplifies as the log,
the people call it -- people do the branching process, or in the language of computer science,
they're trying to explore the breadth-first search on the random graph. And surprisingly
depth-first search is -- works at least if you want a very rough estimate, you don't care about
constant, much, much better. It's much simpler proof. I think. Just the computations are really
elementary, so you can -- you immediately see what's going on.
So let me -- to finish, let me tell you ->>: [inaudible] ->> Benny Sudakov: Uh-huh.
>>: So if you -- the advantage of that research is you [inaudible] paths directly, but in the
depth-first search. But breadth-first search, if you do it one by one instead of just looking at all
the neighbors of one perfect thing, right, so it's exactly the same. There's no -- as far as proving,
say, the larger component, I mean, it's exactly the same argument. It's not really more difficult or
easy.
So the passage from depth-first search to breadth-first search doesn't simplify at all, it just gives
you an additional ->> Benny Sudakov: Yes, yes. So ->>: [inaudible]. See, if you do breadth-first search and you just throw the children on it. It's
exactly the same argument.
>> Benny Sudakov: [inaudible] become depth-first search, yeah.
>>: No, no, no. You still -- you still do breadth-first search ->> Benny Sudakov: I see. So you ->> But just instead of exploring -- so you don't go ->> Benny Sudakov: I see.
>>: See? You just explore the children of a vertex one by one instead of all of them at once, and
then it's exactly the same variable. Same distribution of variables that you have, they're just
ordered in a different way.
>> Benny Sudakov: Yes.
>>: But it's nice to get the long path.
>> Benny Sudakov: Yeah. The same proof. It's essentially you don't change anything actually.
Just the same inequality. You just have simple error terms.
Now so you can apply this to other setting, so let me mention two more settings which kind of
will follow the same way and give you some simple proofs from what people already knew. So
there is a model which people look at. It's a random directed graph, so DNP. Okay? So it's a
directed graph on N vertices.
And, again, the same as before, the probability that IJ is an edge is randomly and independently
for all pairs I and J, but now you're looking into -- you're taking into account both pairs IJ and
pairs JI. So for every such pair you toss a coin, and with probability IJ you put a direct -- with
probability P you put a directed edge from I to J.
So what you can show using exactly the same machinery because depth-first search you can do
also on directed graphs if P is probability 1 plus epsilon over N, then with high probability DNP
contains paths/cycle of length constant epsilon square.
So this is not new result. This was proved by Carp [phonetic], but I think it gives a bit different
proof to what Carp was doing. And, again, that was the same argument, not very different.
Now, one more result, which I want to mention, is -- this is 1 where the same thing works. So
one model people looked at, so if you think about random graphs, what you do, you start with
some arbitrary graph, which in this case is not arbitrary, it's a complete graph, and you toss a
coin for every edge, and with probability P you put it in and with probability 1 minus P you leave
it out.
So you can ask what if I ask all the same question about random subgraph [inaudible] and where
these things of, you know, my graph is complete, what is important about being complete.
And one thing people observed is that you can do the same thing on the pseudorandom graph.
So let me just tell you the definition. ND lambda graph is D regular graph on N vertices such
that all eigenvalues -- so you look on that [inaudible] matrix of this graph, the -- since it's D
regular, the first eigenvalue of this matrix is D, and all other eigenvalues except the first one are
an absolute value lambda. Okay?
So this is one way to define a graph which is -- had strong pseudorandom properties. So if your
lambda is much smaller than D, than edge distribution of this graph resembles the edge
distribution of random graph with edge probability D over N.
So what you have is you have the number of edges between any two sets. S and T is roughly
what they should be. So it deviates from D over N times ST by some small number. So if your
lambda is much smaller than D, then this -- for large sets S and T, this value is much larger than
this value.
So this is the natural definition of pseudorandom graph if you're lambda. Yes? So we'll look on
the lambda much, much smaller than D.
And so what you can do, you can say, okay, start with a pseudorandom graph and look on this
random subgraph over here, yes?
So GP is just random subgraph of G where you keep every edge with probability P. Okay?
And then you can prove a very similar result, which obviously beats stronger than [inaudible]
complete graph, because complete graph is exactly ND lambda [inaudible] where lambda is just
1.
So what you can prove is that claim if G is ND lambda half and lambda is little O of D, so it will
work not necessarily for very dense graph, but obviously this should time to infinity because I
want my lambda to be little O of D, then GP where P is 1 plus epsilon. Now you should
normalize it by D, not by N here, because that's a natural place where you will start having a
large component. S, let's say path, or cycle, in this case, of length [inaudible] epsilon square.
This is one thing which I want to mention. So the proof is exactly the same thing the proof
before, because, you know, once you control a little bit distribution of edges, that's the only thing
we're using here. Yes, we were using that from S to T, there are so many pairs and for all these
pairs I gave you answer no. I didn't put edges there. That's one thing.
Another -- and the third thing which I want to mention, which, again, people look at, is so-called
make or break of games. Okay? So what you do, so you look -- so your board is edges of game.
So look on the edges of the game. And then at every step maker let's say takes one edge, let's say
call out the thread, and break takes, say, B edges, caller calls them blue.
So why we give breaker little bit more power? Because, again, for historical reason people,
when they started this game, they see that for most of the games it's actually very difficult for
breaker and much easier for maker. If they play one-on-one, basically almost every game would
be the winner maker.
So what's the goal? So you take your favorite property. For example, you want to -- maker
wants to create a giant component. He wants to create in red a component of linear size. He
wants the red graph to have a component of linear size. And the question is for which value of B
breaker can stop him and for which value of B breaker cannot.
So you kind of many times getting the parallel results you're getting in random graphs is there is
some kind of stretch called value of B, such that if B0, if B much smaller than B0, the maker
wins. If B much bigger than B0, then breaker wins.
So this -- so goal, let's say goal, for maker is to get component of linear size. So now this is
not -- now there's no randomness here because both maker and breaker can play very
deterministic and very clever strategies.
Still, again, experience shows that you roughly for many problems expect this B to behave
similar to what random graph results suggest. And this is indeed the case. And actually, again,
this is a theorem, so people study this, but [inaudible] they proved that -- that if your B is 1 plus
epsilon times N, then largest component of red graph is constant.
So if you give a lot of power to breaker, so if you give breaker 1 plus epsilon times N edges at
every step, then he can make largest component really not algorithmic constant size, which
depends on epsilon.
And, on the other hand, if B is 1 minus epsilon times N, then maker creates a component of
linear size. So this was the result of [inaudible]. And what you can get using the same
machinery is actually not only you can get a component of linear size, you can create a path, yes,
if P is 1 minus epsilon times N, then maker can create a path of size order of epsilon square N.
And exactly the same proof, because the strategy of maker would be just to kind of every time to
keep. Of course this would not be a DFS, but he will keep this U and every time will try to
extend U to the longer path. And if he cannot, if he already -- you know, some vertices in the
beginning -- in the end [inaudible] would be killed, so he will just, you know, run exactly the
same analysis, come to the first vertex from which he can still get out and get out. And the same
computation works.
Actually, one interesting remark, that here we're really talking about path and not cycle, because
for cycle it's actually not enough. So we can -- you can show that -- that maker, even with that
kind of bias, cannot create any cycle. So for cycle you know this thing should be N over 2. You
know, 1 minus epsilon is not enough. So if breaker has more than N over 2 at every step, he can
prevent maker to create any cycle at all, not even a long cycle, just any cycle. So here the
problem is very, very different.
And let me stop here.
[applause].
>> Eyal Lubetzky: Questions?
>>: I had one. So what can you say about ND lambda graphs when lambda -- if D is fixed and
let's say I tell you that a lambda is an absolute constant over [inaudible] absolute constant
times -- times root D and D is large?
>> Benny Sudakov: I don't think what we're doing is kind of delicate enough to deal with this
case. For example, you give me three regular expander graph. I don't think at least this naive
approach is sufficient this time. I think I need this -- I need really kind of a good control ->>: [inaudible].
>> Benny Sudakov: Yeah. Yeah. [inaudible] just because of computation.
>>: Random D -- random D regular graphs [inaudible].
>> Benny Sudakov: No, no, the result is true. We only ->>: No, I'm saying with this random.
>> Benny Sudakov: Oh, yeah. Yeah. But what I'm saying is just because there you know ->>: [inaudible].
>> Benny Sudakov: If you know concentration of edges have little order of main term, then this
approach easily gives you large paths. But if you only will deduce your edge distribution from
the eigenvalues and D is fixed, then this is not strong enough. You don't get a contradiction.
>> Eyal Lubetzky: Questions? Let's thank Benny.
[applause]