>> Yuval Peres: Alright, good afternoon, everyone. Think maybe all … most people here have studied
probabilistic combinatorics from the wonderful book by Alon and Spencer, and now we have Joel
himself to tell us about the first-order world of Galton-Watson trees.
>> Joel Spencer: Okay, thank you, Yuval. It’s a pleasure to be back in Redmond. I want to talk about a
well-studied subject, Galton-Watson trees, but from a somewhat different vantage point. So let me
begin, though, by saying what Galton-Watson trees are. So this is a model for a rooted tree; initially, it
was a demographic model for the aristocracy of England, which Galton and Watson were afraid was
dying out. Fortunately, they were correct, but … [laughter] so here is the—but they came up with a
good mathematical model—so here’s the model; you start out with a single node, called the root; and
then the root has children; and the number of children is given—at least, this is what we’ll look at—is
given by a Poisson distribution with mean lambda, ‘kay? You can actually look at it with other
distribution, but we want to look at the Poission distribution. And then—so maybe the first one has
three children—and then you go down, and then this one has maybe one child, and this one maybe has
zero children. Each node, the number of children, independently, is a Poi … it has the same distribution,
the Poisson with mean lambda. So lambda will be the critical parameter here, and maybe this one dies,
and well, maybe this one dies. So maybe the whole tree just dies after a while, but it’s possible that it
can go on forever as well; in fact, that’s one of the key things to look at. In terms of probability theory,
the way I’m going to describe it is to have an infinite sequence of i.i.d. Poisson-lambda variables and
then just to say that the root node—the first node, if you like—has x1 children, and then the next node
has x2 children, and the next node has x3 children, and the underlying probability space is this infinite
sequence, though I like to use the phrase “fictitious continuation” here, because it’s quite possible that
the process will stop, as it did in this case. In particular, if x1 equals zero, the process stops. So the
underlying probability space is this countable sequence of i.i.d. Poisson-lambda random variables that
determines the tree, but if the tree does stop in finite time, then the rest of them simply aren’t used.
But it’s very handy to look at it that way.
So this is called the Galton-Watson tree, and now, if you have a property, A, of trees, you would have a
probability that’ll be a function of lambda, which is the probability that the property A holds, as a
function of lambda, and this is what we want to look at: how can things depend on lambda? So I want
to start with two examples that are somewhat similar, but in critical way, from my point of view, are
quite different. The first one, I’ll just write it schematically; what I mean by this is: there exists a node
that has exactly one child, and that child has exactly one child. Okay? So alright, I mean, I could’ve given
you some other one, but this is the one that we’ll look at, okay?
And if we want to analyze that—very nice exercise, but I’ll show you how to do it—we can define it by …
we can analyze it by looking at three states. So the state of a node will be … we loo … see, one thing
with rooted trees is that each node defines a rooted tree—that node and all of its descendants—and
indeed, those things have the same distribution as the original Galton-Watson property. So we’ll call a
node green if the answer is yes—that is, inside the tree generated by v, there is a node, possibly v itself,
that has exactly one child which has exactly one child. Then, we’ll call—we’re gonna have three states—
we’ll call a node blue if it’s not green, but it has precisely one child—this sort of part way toward getting
this, as we’ll see—and we’ll call a node red if else. So to analyze this, we’ll say that a node is green if, in
the tree generated by it, there is such a node, possibly the node itself, that has one chi … exactly one
child with exactly one child; it’s blue if it’s not green, but it has exactly one child; and otherwise, it’s red.
And then, they will have probabilities—let’s call ‘em x, y, and z—but they’re really only two variables,
because they add up to one—the probabilities are.
Now, the thing is that the state of a vertex is determined by the states of its children. So how does that
work? Well, if you have—I’ll just write it schematically—if any of the children are green, then the parent
is green, ‘cause for a node to be green, it means that inside it, there’s this special node-child-grandchild,
okay? So then, all of its an … its parent will then also have this, but it can also be green … let’s see … or
suppose the node has only one chil … exactly one child, but that child is blue, that means that it had
exactly one child, and then, that means that you’re green. Sorry, I’m getting my colors messed up,
okay? That also means that you’re green, and on the other hand, for becoming blue, if you have a node,
and it has exactly one child, and that child is red, then you become blue, because you had exactly one
child, but that child was red, so it didn’t have anything inside it, so you are blue. And everything else is
red. So the state of a node is determined by the states of its children, okay? And these are the rules for
them.
Now, because of this, we can give some equations for x, y, and z. So maybe I should write them down,
because I’ll … so what is the probability that you’re green? Well, either you have a green chill … now,
the … here’s a … the Poisson is particularly nice. Beautiful thing about a Poisson is if you have a Poisson,
if you’re going to have Poisson-lambda children, and each one is a boy with probability point four and
girl with probability point six, then you’re going to have Poisson-point-four-lambda boys and Poissonpoint-six-lambda girls, and those are independent numbers. This is one of the beautiful properties of
the Poisson distribution. So here, what we can think of is if we take a node, it’s gonna have Poissonlambda-x green children, Poisson-lambda-y blue children, and Poisson-lambda-z red children. So what’s
the probability that it’s going to be green? Well, if it has any green child, it’s green; the chance that it
has no green child is e to the minus lambda x. So we get one minus e to the minus lambda x, but we
also might have a single child which is blue, and that is—one can do the computation—it’s lambda e to
the minus lambda times y, ‘cause you’d have to have exactly one child, which is lambda e to the minus
lambda, and then given that, that child would have to be blue, which is y. On the other hand, what is
the probability that you’re going to be green? You have to have exactly one child—sorry, blue—you
have to have exactly one child which is red, so it’s lambda e to the minus lambda z. And I don’t have to
put in the third one, because these are distributions, their sum has to add up to one. Well, this can be
solved implicitly, okay? There’s not any explicit solution, but—you know—there’s a solution, and here’s
lambda, and—you know—it … I don’t know, it … actually, I think it goes up; I’m not … I’m pretty sure it
keeps going up, but that’s not … it’s some kind of smooth solution, okay. Hmm? As a function of
lambda.
>>: Okay, but which function?
>> Joel Spencer: This is x, yeah. This is that, but I mean, I could do it for y or z as well, but see, x is the
event that we want, okay? But—y’know—equally well could be done for … so x, as a function of
lambda, is some smooth function. Okay, well, that’s nice, alright? Now, in contrast, let’s look at the
very basic thing that poor Galton and Watson were so worried about, which is that the aristocratic
families would disappear. So what is the … let’s look at the event that the tree goes on forever; that the
tree is infinite. So the second property is that T is infinite, and now, we can do a similar analysis, where
there are just two states, yes and no. Either v generates an infinite tree, or it doesn’t; it generates a
finite tree. Again, there’s really only one variable, because these are distributions. And again, what we
have is that if any of the children are green, then the node is green; if any of the children—so Adam had
Cain and Abel; Abel, unfortunately, didn’t work out too well thanks to Cain; but maybe the tree is
infinite; we don’t … anyway, so all you need is one child that’s infinite, and then you’re infinite, okay? So
well, this is good, and this is very classical, and then what is the probability—I always write it down
wrong, so let me try and get it—that x is the probability that there is at least one … so you have Poissonlambda-x green points, so you need at least one green point, which means that you don’t have zero
green points, which is one minus e to the minus lambda x.
And if you’ve studied Galton-Watson trees, this’ll be familiar what to you; this is the equation for
survival; and when you graph it, two things happen that are different: the function is not smooth—well,
it’s continuous, but it’s not differentiable. When you solve the equation at lambda equals one, be … for
lambda less than one, the solution is zero; for lambda greater than one, there’s a solution that does not
have … so the right-hand derivative at lambda equals one is two, and the left-hand derivative is zero, so
it’s not differentiable at the point lambda equals zero. So that’s a big distinction from here, where this
function has all of its derivatives equal. Secondly, there is a spurious solution which caused all those
nineteenth-century English a lot of grief, ‘cause they thought the spur … there was a lot of thought that
the spurious solution … they said, “Look at this equation. Answer, hmmm, x equals zero; zero equals
one minus one. There’s a solution.” There’s a lot of confusion about that, least according to Peter
Jagers, who studied the history of this quite a bit. So actually, the equation here: for lambda less than
one, there’s only … the only solution is zero, but for lambda greater than one, there’re two solutions. So
you actually get two functions; the actual answer to the problem—probability that T is infinite—is given
by this curve, but you will—if you look at the equation—you get this solution as well. That’s not the
case over here; this system of equations has a unique solution. So there two points on which these two
examples differ: one is that here, you get a system of equations—in this case, one equation and one
unknown—but it does … the solution is not unique; here, it is unique; and when you look at the solution
to the original problem, here, you get something that’s a smooth function—all of its derivatives exist—
and here, you have a function that’s smooth, except at lambda equals one; but at lambda equals one,
it’s not differentiable. And so the question is: what, if anything, is going on?
So I want to restrict the kind of properties that I want to … that I’ll look at. So our objects are rooted
trees, and I want to restrict myself, in this talk, to properties that I’ll called recursive in the sense … in
what sense? There’re two aspects of it: first of all, there is a finite state space, Sigma, and secondly, I
want an integer, k—fixed integer, k, greater than or equal to one—and when I count things, I’m going to
stop my counting at k; everything that’s k or more is counted the same. And now, something that these
two things have in common is you can describe the property by making a finite number of states—here,
two states; here, three states; but it’s important that it be a finite number—and that the state of a node
is determined by the number of children in each state, and furthermore, that that number, once it gets
to k, it doesn’t matter how much bigger it is. So here, k is … let’s see, do I want it greater than or equal
to … I think I want it greater than or equal to k minus one. No, greater than … yeah. So here, if you have
one … if you have two or more children—I might be off by one—if you have two or more children of a
certain type, then it doesn’t matter. It does matter whether you have one … zero children or one child,
but if you have two green children or fifty … if you have two blue or fifty-seven blue children, it doesn’t
matter, okay? And over here, actually, the counting is either you have zero or you have some. And so
I’ll require for a recursive property that the counting stops at some fixed point.
Let me mention one other case, just briefly. Consider the property that, inside the tree, you can start
with the root node, and you can take an infinite, full binary tree—that is, from that root node, you can
take two children; maybe it has more than two children; you can take two children, and each of those
have two children; then each of those four have two children; and then each of those eight have two
children; and it goes on forever. This refers to something in graph theory called the 2-core; s’been a lot
of work on it. One can, again, do something like this; again, it’s yes or no; and if you have two green—so
k becomes two—so if you have two or more green children, then you’re green. And again, one gets a
recursive formula, and there, something very odd happens: you … the solution is discontinuous. And
some of you, you’re familiar with studies of the 2-core; it’s based on this. What happens is there’s a
critical value, lambda zero, and up to lambda zero, the value … actually, strictly speaking, less than
lambda zero, the value is zero, and then there’s a discontinuous jump, and then the probability that you
have this infinite 2-core jumps to—I forget what number, but it’s a specific number that’s bigger than
zero. So a number of odd kind of things can happen.
So my interest is recursive properties in general, okay. But now, I’m gonna add some logic to the mix in
terms of talking about the properties, and I want to look at what’s called the first-order language in
terms of describing properties. So I know I’ll be in Leiden next month, and then, I’ll have to go very
slowly over the probability, and I’ll go quickly here. Here, I think I’ll just give you some idea of it; if
you’re familiar with it, all the better. So I want to look at statements; so how am I gonna allow myself to
describe statements? I’ll allow the normal Boolean AND, OR, NOT—those kind of connectives—I’ll have
variable symbols, x, y, z; I’ll be able to talk about the root—that will be a constant symbol, the root, r—
I’ll be able to say that x equals y as nodes; and I’ll be able to say that x is the parent of y, if that is a
binary relation; and I’ll have quantification: I’ll be able to say for all nodes, v; or I’ll be able to say there
exists a node, w. Course, I know, that’s a little redundant, but … so what we’re allowing is: for all v or
there exists a w, and we also have equality, parent, and the root, and the usual Boolean connectives.
And properties have to be finitely describable by a finite sentence. So if I wanted to look at this
sentence, I’d say, “There exists w, x, and y such that w is the parent of x; x is the parent of y; and there
does not exist a z such that … or let me put it this way: if … and for all z, what do I say? w, x, y. For all z,
if z … if w is the parent of z, then z equals x—so that says that it has exactly one child—and if z is … if x is
the parent of z, then z equals y.” Okay, so these are the kind of sentences you can make. What can’t
you say? Well, first of all, the sentences have to be finite; you can’t say, “There exists an infinite string,
x1, x2, x3, x4, x5, dot, dot, dot.” There’s no ellipses in this language; each sentence is finite. And the key
thing about first order is that the quantification is only over vertices; you’re not allowed to say, “There
exists a subset of the vertices that has a certain property;” you’re only allowed to say, “There exists a
vertex that has property such and such.” So there a number of things you can say and a lot of things you
can’t say. One can prove that there’s no first-order property that says that the tree is infinite. It doesn’t
look … and if you try and do it, you’ll fail, but that’s actually a theorem that you can’t do it. There’s …
any first-order property, it will not be that the tree is infinite.
Now, so this is called the first-order world, and it’s been quite well studied, and whenever you have a
sentence, A, you have the quantifier depth. So you look at the sentence A, and you look at the degree of
nesting of the quantifiers. So if you say, “For all x, there exists a y, blah, blah, blah, and for all z, there
exists a w, blah, blah, blah,” that’s … the quantifier depth is two, because the z and the w aren’t inside
the x and the y. So it’s a notion of nesting, and we can look at … what we’re going to do throughout is to
fix … we’re gonna look at statements with a given quantifier depth, a. Now, a priori, there’re an infinite
number of those statements, but it’s one of the deep results in—it’s not that deep, but it’s not
immediate—that they’re really only a fini … effectively, they’re only a finite number of classes. So we
can say that T is equivalent to T prime—and I’ll put the little k down as a subscript, but then I’m gonna
leave the k out for—if … so these are both rooted trees; these are … so our objects are these rooted
trees; for the moment, forget about the probability; they’re just the rooted trees. If they satisfy the
same A with quantifier depth of a—let’s say less than or equal to k; I mean, quantifier depth is less than
k, you can always throw in a spurious one that doesn’t matter, ‘kay? And there only a finite number of
equivalence classes, okay? So this I’m gonna just take as a fact; I should mention, though, that the
number of equivalence classes actually goes up like a tower function of k, so … but this is the theory
section, right? Y’know, so [laughs] … alright, so we’ll let Sigma is the set of equivalence classes, yeah.
And now, any first order statement, A, of quantifier depth k is just determined by which subset of Sigma
you are, and Sigma’s a finite set.
Now, in these cases, and in many explicit cases, I can make use of a much smaller Sigma. So here, I use
two states or three states, but in general, I’m gonna have this finite state space, Sigma, which … let me
just denote it by one through m, the states. And we’re gonna let D be the set of distributions on
Sigma—so the set of x1 through xm such that summation of xi is equal to one, and all xj are greater than
or equal to zero. So this is a nice, compact set—basically, an m-minus-one-dimensional space, the mminus-one-dimensional hyperspace … hyperplane, but think of it as the set of distributions over Sigma.
And now, what we’re interested in, instead of looking at the probability of A, let’s look at this Poisson
tree, which has this lambda in it, and we’ll look at its distribution in terms of what state it’s in. And if we
can get that whole distribution, then for any particular property, A, it’s just gonna be a finite sum of
those things. So what we can say is that … let’s write solution of lambda to be the distribution of the
state of this Galton-Watson tree, okay?
So given lambda, we have this probability; we create this random Poisson-lam … this random GaltonWatson tree; and then we look at what state it’s in; it’s in one of a finite number of states, so what are
the probabilities for each of them? Well, whatever they are, that’s gonna be our goal, and indeed, over
here, here, we had only three states and x, y, z, and we saw that they satisfied this equation, okay—this
system of equations. Well, this will now work—ah, almost left out a critical point—the state is … that’s a
recursive function, ‘kay? Well, here, I defined recursive property, but I can also define a recursive
function as—you know—so the value is which state you’re in; it’s the same thing. So I claim that, in fact,
the k is the same k of the quantifier depth. So this is a statement from logic which takes some proof; if
you’re familiar with the Erin Foyd game, one can prove it using that, but I don’t want to get too far
afield; I just want to state that if you have a tree, and you have a node, and you look at its children, and
if you know the state—in particular, the Erin Fo … this is called the Erin Foyd class. So I’ll just state, as a
logic fact, that if you have a node, and it has a set of children, and you know the Erin Foyd class for each
of the children—that is to say, for the tree, starting with that child—then from that, the Erin Foyd class
of the original node is determined, and furthermore, if there are k or more nodes of a particular type, it
doesn’t matter how many there are—so similar to the situation over here. And I said if you familiar with
the Erin Foyd game, this can be proven using the Erin Foyd game, or it can be proven using some basic
logic things that I don’t know how to do that. But I’m just gonna take this as a fact; so just, since we’re
taking it as a fact, let me just repeat this: that … so the state of a tree is really how it behaves with
respect to all quantifier-depth-k statements, okay? And there are only a finite number of states.
Now, I’m saying that if you have a point, and maybe it has fifty-three children, there’s no probability
here, and for each child, you know the state of its tree; you know, for each first-order statement of
quantifier depth up to k, you know whether it’s true or not on that tree; and furthermore, that if more …
if k or more nodes have the same state, all you need to know is that they’re at least … you don’t need to
know how many there are. Then, the state of the original tree is determined—so that is to say
something like this will occur—they’ll be some determination, which will be a little more complicated to
describe, that goes from … so here, what you have is number of green, number of blue, number of
yellow; if the number of green is omega … no, if the number of green is one—the counting is zero, one,
or omega, omega meaning greater than or equal to two—if the number of green is one or omega, then
you’re green. If the number of blue is one, the number of green is zero, the number of red is zero, then
you’re green. If the number of green is zero, number of blue is zero, number of red is one, then you’re
blue. Everything else is red. There will be a similar thing for the Erin Foyd class, okay? So that, I’m not
giving the proof, but it comes out of the logic. So now … yeah, question.
>>: Question? Is every first-order property just given by some existence of a sub-tree?
>> Joel Spencer: Sorry?
>>: Is every first-order property just given by the existence of a certain sub-tree like in your example?
>> Joel Spencer: No, that’s not really true; I mean, these are existential statements; you can make more;
you can say, “For all x, there exists a y such that for all z, there exists a w.” You can make ... I mean, you
could say that be … that if every time a … you could say that every time a child and a grandchild had
exactly seven children, then all seven of the …
>>: Sounds like you’re describing a sub-tree when you do it.
>> Joel Spencer: Well, it come … there is a localness to it; it does depend on finite things; that’s true,
yeah. So in a certain sense, you’re right, yeah, there is a locality here that really is important, ‘kay. So
now, I want to get the solution as a fixed point, and so I’m gonna define a map, psi, depending on
lambda, from distributions to distributions, and the solution is gonna be the fixed point of this map, psi.
So the idea for psi is: you have a distribution over the sates, and now, you take a point, v; you give it
Poisson-lambda children; and then each child you give a state by means of this distribution; and you do
them independently. Now, you know the states of all the children; therefore, you know … you’ve
determined—in this way that I’ve just stated—that’s determine the state here. And if everything’s going
to work, we’re gonna have a fixed point; if that’s gonna … the solution is gonna be the fixed point,
because … or so this is a map from distributions to distributions. Once again, you’re given any
distribution over the states; you take a point, give it Poisson-lambda children, give each child, i.i.d., a
state from this distribution; that induces the state of the parent—it’s the distribution for the parent.
And what happens is that the solution is the fixed point of psi—again, I should write psi sub lambda.
But what happens here—what we’ve been able to show—is that, in the case of first-order statements,
that this psi has a nice … some nice properties. First of all—maybe most important—the fixed point is
unique, so unlike the situation that I erased, where you have two solutions, there’s going to be a unique
solution to the equation psi of x equals x. Secondly, if you think of psi as a map from the distribution
space to the distribution space, it’s a contraction, okay? Points are getting closer together.
>>: Which the metric?
>> Joel Spencer: Now, if you take a high enough po … if you allow yourself to take a high enough power,
then the metric becomes irrelevant, because if it’s contracting in the—say—the TV metric, then if you
take a high enough power, it’s really contracting in the TV metric—total variation metric—and
therefore, it’s contracting in the L2.
>>: But which metric is the most natural? Which is the one where you first [indiscernible]
>> Joel Spencer: Total variation, total variation, yeah. Although, for application, we really want the L2
metric, yeah. But well, we’ll see the total variation metric is the natural one to look at. So the results
are that the … they’ll be a unique fixed point, and even further—I mean, what we actually prove is that
the map psi is a contraction map, so in fact, then it has to have a unique fixed point—and so the solution
will be given by the unique solution to a finite system of equations, and all the equations just have the
variables and various lamb … powers of lambda and e to the minus lambda floating around. So they’re
nice functions, and from that, one actually gets that the—from the contracting property—that the
solution … so the results are that it’s contracting—I think that’s sort of the main result from which other
things follow—it’s a unique fixed point; and it’s a smooth function—that is, all of its derivatives exist, so
it’s not like the place where it’s not differentiable; all of the derivatives exist—in fact, it’s even more; it’s
real analytic; in fact, it’s even more, ‘cause it is the solution to these equations, it’s called an algebraic
function, I guess is the word, so everything … so these are the results that things are very nice about it.
Let me give you some idea of what’s happening here and bring up another definition that turns out to
be important.
>>: It’s algebraic in lambda and e to the lambda from these two parts.
>> Joel Spencer: Right. Yeah, that’s right. It’s …
>>: The ring lambda.
>> Joel Spencer: Well, that’s right, yeah, yeah. But these are smooth functions. Let me bring in another
definition that I like. So remember that I said that we consider the Galton-Watson tree … that the
underlying space is this countable sequence of i.i.d., Poisson-mean-lambda variables. So let me say that
a property—or for that matter, function—A, is rapidly determined if—I want to reintroduce a notation
of Knuth that unfortunately died away, but I think it’s really a wonderful … I want to say “fairly surely,”
which he introduced some decades ago. Fairly surely means that the chance that it doesn’t happen
drops exponentially, okay? So let me just introduce that for today; it never did catch on, but I think it’s a
very useful thing. So something occurs—there’s … here, they’ll … you’ll see there’s an underlying
parameter, s—so something occurs fairly surely if the chance that it doesn’t occur drops exponentially in
s. If, fairly surely, x1 through xs—let me emphasize it by writing tautologically—determine our … either
the veracity of the property or the … maybe it’s a function, and fact, the actual thing is: we’re gonna
look at the Erin Foyd value. Let me give you an example of something that’s not rapidly determined:
whether or not the tree is infinite. So consider the property that the tree is infinite, and think of lambda
greater than one. If you have x1 through xs with a positive probability—I mean, bounded away from
zero—at the end of x1 through xs, you’re gonna have this huge number of nodes that you know you
have, but you don’t tautologically know that the tree’s gonna be infinite; you know it’s highly likely that
the tree will be infinite starting from there, but you don’t tautologically know. So being infinite is not
rapidly determined, least when lambda’s greater than one. So you’re fairly sure that you’re fairly sure,
but you’re not fairly sure that you’re tautologically sure, and that’s the difference. And …
>>: I might have to cut you off here. [laughter]
>> Joel Spencer: And the claim is that Sigma, depending on k, is rapidly determined. Now, I don’t want
to give the whole argument; let me give the argument for this particular statement. So look at the
statement that there’s a node that has exactly one child that has exactly one ch … notice that that
doesn’t have limiting probability zero or one; it’s somewhere in the middle. Y’know, but I want to claim
that it’s rapidly determined, okay? So let’s fix x1 through xs. Now, what I … the way I want to examine
this is I want to use fictitious continuation. So what I want to say … so we’re just gonna look at this
statement. In fictitious continuation, I want to use the x’s to generate not just a tree, but if the tree
dies, I’m gonna start another tree; I won’t call it the root anymore, but I’ll just start another one. So let’s
define a new process, based on the xi’s, that will use all the xi’s; we just go along, but whenever
something dies, we just start with a new node. So—y’know—maybe we start out—y’know—suppose
we start out three, zero, zero, three, zero, zero, zero, two; the first node would have three; the next
would have zero; the next would have zero; the next would have zero, but then, instead of the process
stopping—so this is the root—I’ll add a new vertex that has two, and I’ll keep on going. Now, I claim
that, fairly surely, in this structure, there’s gonna be a node that has exactly one child that has exactly
one child. ‘Kay, so this structure is not ever gonna stop, so I’m gonna take it out to s, and I claim that
there’s gonna be … and by that, I mean that it’s already determined by time s, so that there’s a node
that’s had exactly one child that’s had exactly one child, but furthermore, the grandchild’s children …
sorry, we don’t … yeah, no, that’s all we need.
So why is that? Well, I mean, there are a number of ways of proving it; I like to prove it using
martingales. We let I sub i equal one if I has exactly one child which has exactly one child, and we’re
gonna let y be the sum of I sub i for i less than or equal to epsilon s, and here’s a little technical part. We
don’t want to go up to s, because if we look at the point s, x1 through xs haven’t yet determined what it
… they’ve determined whether … how many children s has, but if s has one child, we don’t know yet
whether that child has had one child, but if we stop at epsilon s, where we pick epsilon; it’ll depend on
lambda; if we pick epsilon small, then fairly surely, by the time when we get up to epsilon s, not only …
so if we only look at the nodes up to epsilon s, all of their children and all of their children have already
been determined; so that you can show. So I only want to go up to epsilon s, and I look at this, and now,
I say that the expected value of y is some constant times epsilon s, ‘cause each node, the probability
that has exactly one chi … kappa’s lambda e to the minus lambda squared—has to have exactly one
child, lambda e to the minus lambda; that one has to have exactly one child, lambda e to the minus
lambda.
So the expected value of y is kappa times es, and now, I want a large deviation result; I really want to say
that y is … probability that y is zero is exponentially small, but I can run a martingale on y. So I think it’s
pretty much required that the word martingale comes up in any of these talks. So we run a martingale
on y, where we look at the expectation of y as we look at x1, x2, x3, et cetera. What can be the effect of
xy … sorry, xi? So yi is the expected value—I shouldn’t use i—yt is the expected value of y given x1
through xt, and now, I want to look at how our expected value changes when we say how many children
child t—the tth child—has. Well, that can affect whether t has exactly one child that has exactly one
child; it can also affect whether the parent of t has exactly one child which has exactly one child, but it
can’t affect anything else, and this is a tautological thing. It … the knowing how many children the tth
child has can only affect the … t itself and the parent of t. So what happens is: you have a martingale;
each additional piece of information can affect things by at most a constant—in this case, the constant is
two—therefore, you can apply Azuma’s inequality, so you have a large deviation, and you actually say
that so the probability that y is zero is exponentially small; in fact, actually, the probability that y differs
from this by constant s is exponentially small. I don’t know that we actually … in some later things, we
might use that … might … that might be useful, but I don’t think we’ll get to that, ‘kay? So now, what
does this mean? Does this mean that the probability of the event is going to one? No, because this was
with fictitious continuation.
So now, what you say is when you look at x1 through xs in the fictitious continuation, fairly surely, this
has occurred. Now, what’s happened is either the process has stopped b x1 through xs, but then we
know whether the … we just look at the tree, see whether it’s true or not, so then, we absolutely
tautologically know whether there was a node that had exactly one child that had exactly one child, or
the process hadn’t stopped by xs, but then if its hasn’t stopped by xs, then the fictional continuation is
what actually did happen, and so therefore, in that case, fairly surely, it did occur. So we either
absolutely know it, or we’re fairly sure we know the answer; putting them together, we’re fairly sure
that we know the answer. So what happens is—you know, I’ve just done it with this statement, but it
turns out, it works more general—that these statements are rapidly determined, and I think, somehow,
that this is a critical property; if we want to move away from the logic, this is the metaproperty that we
want to look at for the properties that it’s—or at least, one of them—that it’s there.
Let me just say a couple of words about the contraction. I’ll just do the easy case, where lambda’s less
than one and why this is a contracting map then, but I’m not gonna give the whole argument. So with
lambda less than one, which is actually—I mean—there a lot of ways, there—you know—the tree’s
gonna be finite anyway, but still, I want to say that when lambda’s less than one, that if you use the total
variational distance, then you’re contracting. So the idea is: take a node, and let’s condition on it having
t children, and on the one hand … so you have two distributions on the state space, x and y, that have
total variational distance epsilon between ‘em—epsilon does not have to be small in this case—epsilon
between ‘em. And so conditioning on it having, say, four children—and suppose that the total
variational distance between x and y is epsilon—now we couple the two; we give each node here i.i.d. x;
and then we couple it with giving y over here; and what’s the chance that the state up here is different?
Well, if in the coupling, we wound up giving exactly the same thing to all four, then it’d have to be the
same, but each one, because of the coupling, only has probability epsilon of getting a different thing,
and so even just taking their sum, the chance that you would get a different thing for … so in this case …
>> Yuval Peres: Well, so since this case of lambda less than one is so obvious, maybe you can remark on
the other cases. We’re past time.
>> Joel Spencer: Okay, yeah. Oh, oh, alright. I’ll just … let me just finish this one up here, just for a
moment, and then I’ll remark on the other one. Yeah, so here, it’s just lambda epsilon … oh, sorry, it’s
four epsilon, but four has an expected value of lambda, and so it’s there.
So what happens in the … when lambda is greater than one, I’ll remark on the … what happens then is
it’s more complicated. You go down … so instead of psi, we’re gonna iterate psi, which means the
following: we take a point, we go down s generations, and then at the s generation, we give all the
nodes from distribution x, and then we backtrack all the way up and get the original thing. So I’m gonna
take s to be s0 plus n; first, I’m gonna choose s so big that by the time we get down to here, the chance
that we’re not determined already is exponentially small, so let me just say it’s less than epsilon one. So
before, I said … now, notice before, I was looking at nodes one at a time; here, I’m going down s
generations, but that’s even more than one at a time. So what happens is: it’s only with probability
epsilon that the x is gonna have any effect at all; otherwise, we’re … but that’s not enough for
contracting, because that epsilon is fixed, and—you know—maybe x and y are really, really close. So
now, we say, “Suppose that the number of vertices down at level s is t,” and we have … and we’re gonna
… we don’t have anything about what t is going to be, okay? But what we want to say is this: if t is small,
then the contracting argument is gonna work, because the … these t are gonna give t times lambda to
the n children, so that would give an extra factor of t lambda to the n, but we have a factor of epsilon
that is gonna have any effect at all and so would be okay.
The problem is: what if t is large? What happens then? Well, what happens then is we go down another
n levels to the—you could take n to be like four to the k, but I mean, that’s the technical part. These are
independent trees; if, inside of these trees, every type occurs, and every type occurs at least k times,
then everything will be determined by down … by here. ‘Kay, again, that follows from … that’s one of
the logic parts of the argument—that is, if every kind of tree occurs inside here, of a fixed size, and
occurs at least k times, then everything will be determined, and the chance that that won’t happen is
exponentially small in t. So the chance that it’s—so I’ll call it bad if it’s not determined—the probability
that it’s bad is exponentially small in t; when it is bad, we’re getting an extra t times lambda to the n,
which is hitting us on the … the contracting is becoming expanding, but it’s t times lambda to the n, but
times e to the minus beta t. So when t is big, the e to the minus beta t is gonna cancel the t. So when t
is very large, what happens is, again, it’s just a contract, so this is—I said—an outline of what’s the most
complex part of the argument that shows that, indeed, it is contracting. And you don’t need the
contracting to show the unique fixed point, but you do need it to show the … that the function is real
analytic.
So let me mention some other possible things to think about here. One thing is: if you have a recursive
property, does the recursive property uniquely determine—or maybe uniquely determine up to
probability zero—the event? So if you think of: that if you have a green child, you’re green, okay? I
used that for being infinite, but there’s another model with that same rules for green and red; just call
every node red; no matter what it is, just call it red; then it’s gonna have the property that if you have a
green child, you’re green; and yet, the probability that you’re green is gonna be zero. In fact, that’s the
spurious solution. So what happens is: when you have the rules for the recursive function, they may not
determine uniquely the property, and indeed, that’s actually the case for having a single child that has a
single child, because then again, do the green, blue, and red, except now say that if a point has an
infinite tree below it, just call it green; don’t look, just call it green; well, that’ll still have the property
that if it’s green, it’s green. See, if you have a finite tree, then the leaves are determined, ‘cause they
have no children, so their col … their state is determined, and then you can backtrack. So when you
have a finite tree, everything’s determined, but if you have an infinite tree, parts are not determined.
So in the case of having a single child with a single child, there also is a second solution, but that second
solution has the same probability, because—you know—when you do have an infinite tree, you’re going
to have the property. So there’s some connection here with: what about the uniqueness, or uniqueness
up to probability zero, of recursive properties?
There is … there’re questions about—alright—here off, I started out with this from the logic point of
view, but what if you just start with assumptions like rapidly mixing or maybe something stronger or
weaker? Can that, by itself, tell you some things about the property? Always, the goal is to say
something nice about this function, is to say something nice about the … or to say that there isn’t; there
cases where it’s not nice about it. And let me add one final question that I’ve been puzzling over and
haven’t done. I can eith … as was pointed out, the … this model has locality; I mean, basically, these
first-order statements are … you’re really kind of talking about local neighborhoods in some way. So I
can destroy that and keep a first-order language; I can add a first-order binary predicate that x is an
ancestor of y. If I add that predicate, I still have a first-order language; it still has the property that
there’re a finite number of Erin Foyd classes; it’s so … and so you still get everything as before, except
that you don’t … I certainly can’t get these results, and I’m not even sure that these results hold. So one
question is: can you come up with a sentence involving ancestor, where the function f of lambda is not a
nice function? And I think that’s a good point to stop. Thank you. [applause]
>> Yuval Peres: Comments or questions? Regarding one comment you already made in …
>> Joel Spencer: Yeah.
>> Yuval Peres: … Sweden was the one that … two vertices in the same level is problematic element if
you were to add that to y our language.
>> Joel Spencer: Yeah, the problem is that if you put in that binary statement, you can actually say that
the tree is infinite, because then you could say that for all x, there exists a y at the same level that has a
child. So there’s … this logic business is a tricky thing—you know—you keep thinking, “Well, let’s
strengthen the language,” and sometimes very quickly, you strengthen the language, and—you know—
you just get—y’know—you get stuff that you don’t want. Ancestor, I’m just not sure; that’s a … so that’s
why I’m pulling back a little bit, thinking about ancestor.
>>: Alright, so you don’t have the contracting property in the ancestor case.
>> Joel Spencer: Sorry?
>>: So the contracting property doesn’t work in the ancestor …?
>> Joel Spencer: I don’t know. I don’t know. My guess is it … certainly, the proof doesn’t work …
>>: Right.
>> Joel Spencer: … because all the proofs serve as … seem like you were … your insight was that there’s
a locality to what’s going on, and in a certain sense, that permeates all the arguments that you can look
at … if … the notion is that … so just noticing … if you have a tree—well, there’s the neighborhood of the
root; you have to know about, I mean, after all, I mean, the … you can make statements that the root
has five children, ‘cause the root’s a constant. So there’s the neighborhood of a root, but otherwise, if
you’ve got—fixing the quantifier depth, k—if you got, sort of, for each of a finite number of classes, you
have k copies of sort of sub-trees or bushes that look like that, then the Erin Foyd game … the Erin Foyd
value is determined—that and what’s happening near the root. So in particular, for infinite trees, when
conditioning on the tree being infinite, you’ve got every possible local configuration, and so what
happens is: the theory really—if you condition on being infinite—it collapses in a nice way, that the
probabili … for any statement, A, you only look at what’s happening locally near the root, and how far
down from the root just depends on the quantifier depth of A, and if you know that, then you know
whether it’s going to be true or false up to probability zero. So yeah, ‘kay.
>> Yuval Peres: Okay, so let’s thank Joel again.
>> Joel Spencer: Thank you. [applause]
>> Yuval Peres: Your …