18062
>> David Wilson: So today we're pleased to have Anne Fey from the Technical University of
Delft. And she's going to tell us about splitting the sandpiles.
>> Anne Fey: Good morning. And thank you for coming, just in time. So my talk is about limiting
shapes for splitting model, which is a particular kind of sandpile model and notably, well it's not
abelian, and that's kind of a contrast because already a lot is known about abelian sandpile
models and this will put people off because it's not abelian and that gets rid of most of the proof
techniques that are used so far. So let's see how far we can get with this model.
First, I should say what we mean by a sandpile growth model. So in the sandpile growth model -I'm going to take my notes -- we start with some initial configuration. We place a number N at the
origin. And H everywhere else.
I will do some small examples in a moment. And typically N is large and H is not so large. And
then we stabilize this by a sandpile rule. If it's abelian sandpile model, can I abbreviate it like this,
abelian sandpile model.
Then I look at my sides, at my grid and I say is there anyone who has more than 2-D then you
should give one to each neighbor. And that's called abelian toppling. If you do splitting, then we
say if right is at least one, then we do a fraction. It splits the entire content of that site. Say one
equal portion goes to each neighbor. So let's do a small example on just the line dimension one.
Say it puts 3 at the origin and 0 everywhere else. Then, okay, for every small example. Okay. If
it's abelian sample model, then this one it's more than two. It should give one to each neighbor.
And then it's finished. If it's a splitting model, then this is more than one. Then it should split to
equal half and go to each neighbor. We have this. And then it's not finished because these two
are still more than one and they have to split again.
And it looks like this. And now we need one more step. You can see so what is norm abelian
about this, was this was a very small example. But let me make it a little bit larger. Instead of 3, I
put 4 here. We start again. This time I make another decision. I don't split them both at the
same time. I maybe split this one first. Now, you see it's going to make a difference what
decision I make next. Should I split this one first, then I get another symmetric configuration, and
I carry on. And I get some final results. Or should I split that one first, then the final result will be
asymmetric.
So it will be a different result. So that's normal abelian about the model, because with this
toppling rule, it never matters what order you do. You can do every unstable site at the same
time or you can do them one at a time. You will always get the same results.
And this example it matters a lot. So ->>: Did you keep the splitting to correct the rules so only send to leave max 1 at the site. Send
only the excess, then this problem disappears.
>> Anne Fey: Then there's not a name. It's called again?
>>: We call it divisible.
>> Anne Fey: Divisible sandpile, yes. Again, it doesn't do the nice things that our model does.
You'll see in the second half. So we focused on two possibilities. We have some results that are
valid for any splitting order you choose. But mostly we focus on parallel order that's symmetric.
Every time step you locate all the sides that are at least one and you split them all at the same
time.
So what else? So that is information on what we mean by growth model and what are we
interested in? Well, we want to know if say these were very small examples. But if you put a
huge amount here, we spread it out. I imagine it will stop it some time. But maybe we can
choose this H a little bit larger. There will be more mouse around and maybe it will never stop
splitting. So we make a distinction here.
Robust, that means we have a value of H. Short stats no matter how large we make N it will
always stop eventually. And explosive, that means if H is another value and there is some
threshold N, such that if you put this N there or more, and we start splitting, it will never stop.
>>: For which toppling order?
>> Anne Fey: Well, depends. For this one we can prove a bit more than for that one. Then we
are interested in limiting shapes.
>>: Where did the ->> Anne Fey: I'm sorry?
>>: Where did the French terminology come from?
>> Anne Fey: Well, it was late in the night and we were tired. And we decided on these names.
And the referees didn't object any further. So I think in the first attempt the referees didn't think it
was very appropriate, but we managed to defend it.
So limiting shape of what? Well, what we do is when we are finished and we give special color to
all the sides that are split or toppled at least once. So that would be this one and now that one
also splits. This one splits again, but it's not finished. That one will split. And so you get a set of
sides that splits at least once. And it will have some shape and this will depend on N and H. But
maybe there is a limit.
>>: What was the condition for coloring? Color of the split?
>> Anne Fey: At least once.
What you did for abelian sandpile models you take N to infinity in this robust case when you have
end results, and it turns out it can be a limiting shape. Oh, we didn't bring your poster. There
were some nice abelian sandpile examples on it.
>>: I think they're on here so ->> Anne Fey: Never mind. Okay. What we didn't do before, but what we're going to do today, is
look in the explosive case. Never thought that was something to look at, because you don't have
an end result. It never stops. But well if you do this parallel toppling order you have a process in
time. Every time step it spreads further and you can look at the limits time to infinity and see how
it explodes.
Growth rates, that would mean, well, it's growing as a function of time. If it's exploding or as a
function of N. If it's robust and want to know how fast it grows.
So weird examples. This is all nice to look at in abelian sandpile model, but it's a bit more
troublesome in this nonabelian splitting model. Let me show you a weird example.
It's not completely N at the origin and H everywhere else, but it's nice to look at anyway. We
have 1.4, 1.20 and the rest is .9. So what's strange about this example? Well, let's stabilize this.
There are two sides that have more than one. So they will need to split. You could choose the
parallel order.
Then what does it do? This one puts .7 here and there. And this one puts .6 here and there and
nothing else changes. So it's finished in one time step. But if you take another order, let's say we
split this one first, well, it's two. It needs to split again. These two are one. They will need to split
again and now 1.4. Well, you can imagine that not only does much more than the previous
toppling order, it's never going to stop. So there's something strange here, if it's going to stop at
all or not. We're not even sure. It depends solely on the splitting order instead of just on H.
>>: We're never going to stop truly every site if it's -- if it's an amount of max [phonetic].
>> Anne Fey: There's an example, yes. So that's the question mark. And then this in a sense
we take N to infinity. You might imagine that it's a property of this model that if you choose, if you
have some N and H and you say, okay, it spread so far. You make N a little bit larger, it will
spread further. That would be a logical thing to assume.
But as it turns out we have a counter example. If you take, okay, the numbers are rather
particular. I bet it happens as N is 5.36 and H is .33, and stabilize it, you find that 11 sides split.
But if you increase -- sorry, wrong example. This one. 11 side splits but if you increase N a little
bit to 5.22 and stabilize it again only nine sides splits. So it's not monotone.
And then, well, while we were starting to look for nice strange examples, we found another one.
These values. That's all just on the line. So you stabilize it. You find that 11 sides split. But if
you increase H a little bit to .36, and then only nine sides split. So it's not monotone in N or H.
So that's another question mark here. And the abelian sandpile model you can say if you find
some value of H where it's explosive, then also all the larger ones they will explode. And this
model, well, question mark.
So in this another question mark. And this growth weight, well, all the most of the known -- no,
that's not true. Never mind. I'm going to make a table here that summarizes known results for
the abelian sandpile model.
So in this abelian sandpile model, you have particular -- you have grains. They move as integers.
So you choose H only as integer. So it's very easy to see if you, for some value N at the origin
you will start toppling. It will never stop.
You can choose D mine must 1. So it's very easy to see if you, for some small value of N at the
origin you will start toppling. It will never stop. Because every site that has a neighbor that
topples out receives at least one it will be 2 D it will topple itself. So this is explosive. 2 D minus
2 down to whatever smaller value you can find. It's robust. Right here. D minus 10. You can
even do negative values of H. You can go to minus infinity. There are some limiting shape
results known. It's known to be this one. You choose H is 2 D minus two the limiting shape will
be a cube. If you take very negative values of H you take it one to infinity, it's a sphere. In
between question mark. There are very nice shapes. You can look them up on David's poster,
but there are no proofs about them.
Then growth rates. It was proven from here on down that you add N to the origin. You spread it
out, it's going to grow like N to the power 1 over D. Actually, it turned out it was an error in the
proof, and it was only valid from below 0. We fixed the error. And managed to prove it all the
way up to D minus 2. So nice results.
Then here it was explosive, so the results never mind about the growth rate. So now I compare
that with splitting model.
>>: What about the [indiscernible].
>> Anne Fey: Sorry?
>>: You also have P goes to infinity.
>> Anne Fey: Yes.
>>: The answer there is for all things?
>> Anne Fey: It would only be this value of H. And then in the first you would have to choose a
toppling order. So you might choose this parallel order. So first time the origin topples. Next
time step the neighbor stopple, et cetera, so it just spreads linearly. You can show it was not in
the paper but it's not too hard to derive. So what about this splitting model. Well, I put it at the
same height as this value, well, there's a factor 2 D between them. So this -- so by the same
argument as here, well, that would have to be explosive, since if a site has a toppling neighbor, it
receives at least 1 over 2 D. It will become at least one itself. So every one topples. That goes
for arbitrary toppling order. For parallel, however, you can go a bit below that. .
So to compare if you do dimension 2 then this is three-quarters and this is 7 over 10. So a little
bit less. You can say for every H at least that's explosive. Then what do we have here?
>>: [indiscernible].
>> Anne Fey: Sorry?
>>: [indiscernible].
>> Anne Fey: Oh.
>>: Maybe ->> Anne Fey: Hmm.
>>: On the left side of it. The page.
>> Anne Fey: Oh, again. Yeah. Should we copy those values?
>>: No, no.
>> Anne Fey: Make a bit of room here. So that was explosive and robust. Now we make the
next one. Okay. Growth rates, because that's sooner finished. What we have is fortunately the
technique to prove this N to the 1 over D, it uses green functions for random works. So it doesn't
use abelianness. It doesn't require abelianness. And we can adapt that proof for the splitting
model but it only works for H less than 0. So no new proof technique needed here. So the thing
is for the abelian sample model you can go all the way up to H, 2 D minus 2 but here no such
thing. Because for H more than 0 you need abelianness for the proof and that fails for this model.
And they're limiting shapes. Now it's interesting. Because for H at least one half I put cube with a
question mark. Why is that? Well, we can perfectly well proof that if it stops, then it will be cube.
But we're not sure if it stops or not for this H value, because we only know it's robust for strictly
less than one half.
This follows from the proof of that one. So it's a same story as before. This is as just explained
for the abelian sample model, you choose the parallel toppling order, first time set origin topple
next time set all the neighbors. Then the neighbors grows like a diamond in time. So it's a
limiting shape. For the abelian sample model, there is nothing in between here, because you
have integer values of H. Only one explosive value. For splitting model you have many values in
between here. And it turns out all sort of strange things happen there. We find (writing on board)
in this very tiny range, that was going to be that way, so it's a very small interval between point
seven and point 75 for dimension two. You see many different things happen. We can prove a
square. We can prove an octagon SD to infinity. And I think we only just started exploring that.
So next I'm going to, where is the cap? There it is. Just to show you what happens there. So we
switch to the screen now. I'm trying to wake up my laptop. So this is a Mathlab program to
simulate the splitting model. What I did was write a program that's, it calculates exact values,
because if you naively program this splitting model, you say, okay, you make a split and
dimension 2 so you divide the side by four and go on lots of times, where every new time except
you divide by 4 so very quickly you get rounding errors. And I didn't want it, because to decide
whether to split or not you have to see if it's exactly one or not. So you don't want rounding
errors. So what I did was, well, make powers of two and keep every one of them in arrays. So
it's a huge and very slow program. But we only want to look at small examples. So it will work.
But that's why I have to choose H a strange way. That's first. Let's start with a large H. So you
see one-half plus one-fourth plus more, it's going to grow like this diamonds.
What is this? It's the size of the grid you're going to look at, and this it's not N it's 2 to the power
N. No, N is 2 to the power 3. This is a predictable diamonds. Not much news there.
Let's try another value. That is below three-quarters. So do this. So totally different behavior. It
still grows linearly in time, but you can clearly see the limiting shape is going to be square.
So it stops when it reaches the boundary. See how slow it gets after some time. That's because
I have more and more powers of one-half.
>>: Always linear in time, explosive?
>> Anne Fey: No. For these easier examples, you can clearly see. So let's look at another one.
I make H a little bit larger and see what happens this time. It's a little bit more than a square.
Because H is a little larger. So some sides can decide sooner that they want to split. And I'm
going to convince you that in the limits this is going to be an octagon. It's that slope ->>: Doesn't it seem like it's spreading more in the X axis than the Y?
>> Anne Fey: That's because my figure is not square. [laughter] that helps. And never know
why Matlab chooses this figure size. But it's really symmetric. Sorry about that. So now that
we're added, I show another value. Make H a little bit larger than this. And then try again. It's
another octagon. So what we did so far is we have a proof for these diamonds that you can
imagine. Just did that in two sentences. You can prove this for square that I just showed you.
More or less the same methods. A little bit more elaborate. We can prove this square ratio
octagon that I just showed you, which is getting very elaborate. And this one, well, Ion was
getting enthusiastic. She said I can prove another octagon, so she started spreading on this one.
It's not simple. I'll show you in a minute what these sort of proofs look like.
First another demonstration. So I wanted to show -- no. This one as well. It's like the octagon as
before, but I think a little more than that. So I think it's a polygon at 12 sides. We can go on with
that. We've just seen a few examples.
>>: You're saying these are not rounding errors?
>> Anne Fey: I'm sorry?
>>: These are not rounding errors?
>> Anne Fey: Well, to calc, to show this figure I add all these powers of one half and that might
get rounded but the calculations are exact. That's why it's so slow. You're getting tired of this.
Want to see more demonstrations?
>>: How much precision do you end up needing for a picture this size?
>> Anne Fey: I'll have to look. Because I didn't care about large scale simulation. I see more or
less what happens. I tried to prove something. I didn't run them for a really long time. And I
checked after very few steps you already get below machine precision. So this is definitely you
need the exact program.
>>: If you runtime TB, do you need to store T?
>> Anne Fey: That's what I do. It's possible that I didn't write the most efficient possible
program. I just keep everything thinking, well, I'm not looking for optimal speed anyway.
So just to introduce the proof method, I'm going to look at this simple diamond again. Now
step-by-step. Small example. So what we see here times 0 there's N at the origin. There's H
everywhere else. And N is more than one. So that's really all the information you need to get this
diamond. You don't need to know exactly how high it is. Just that it's -- well, it's more than one.
It's unstable. And all the others are H and H is at least two quarters. So that's only two states
that I'm interested in.
Instead of continuous infinity, many possibilities. Should I go one step further? Okay. Now the
origin is empty, because it just splits. So now I have three different kinds of sites. The ones that
are still H, the ones that are unstable and the ones that are empty. Only three kinds. I'm not
interested in what precise value they have. And if I keep going from this point, it remains like that.
All I need to know is for every side is which of the three states is it in. So in fact it is a cell
automaton with three states and I can write it down like that. I can say every empty sites that has
four unstable neighbors it will be unstable the next time step, because it receives at least one
over 2 D from each of them and at top you get at least 1. So every site with height H that has at
least one unstable neighbor, it will be unstable the next time step because it already has
three-quarters and it will get at least one quarter every unstable site. It will split. It will be empty
the next time step. Couldn't have an unstable neighbor? No, because we do this parallel order.
You never have two unstable neighbors. So instead of this splitting model with rule, you can just
describe it as a cell automaton, with three states. So that's what we did. It's defined as a cell
automaton with transition rules. And states space and we proved the limiting set theorem for that.
Why do we do this so elaborate? Because we want to use this method for the other, for the other
shapes as well. And there it gets a bit more elaborate. So let's look at this square again in steps.
Same situation. We have H everywhere. H is less now. We have N at the origin. It splits. It
sets off the neighbors. At first it likes to be a diamond, but very soon -- well, this one couldn't split
yet. Because it didn't -- it got some amount from the neighbor but not enough to reach one. So
this is not a state. It is H plus something but it's not run yet. So we need more than three states
this time. In fact, what we need is well we have empty sites again. We have H. We have this
kind that is almost one so I gave it a letter P for poised about two splits. But not yet. Then we
have these. That one is unstable. But only barely. So I gave that another letter. It's a new state.
Well, marginally unstable. It's M. And in this one you see it's a little higher than that. So it's a
different kind of unstable. And I gave it a letter D. Why is that? Because it had in the previous
time. So it had two neighbors that split. So it gained at least one half and is more above one
than this one who got only one portion.
And then okay I have these ones in the middle that I don't really care about because everything
interesting happens at the boundary. So called them C for central.
And a cell automaton with seven stage. Didn't I just name six?
Yes, but I needed the seventh one because what I do is each of these stage that has a letter it
corresponds to an interval of heights. And without a seventh one, I got interval -- I couldn't find a
value of H that satisfied everything. So I had to complicate it a bit. One step further.
Now, let's see what happens. So this one, it doesn't split. But three of its neighbors will. So next
time it will get very high and it's in the class of one of these ones, the diagonal ones. It received
more than one portion. So what consequence does that have? Well, it will split, of course, the
next time step.
But it will set off its neighbor. This one got a portion from only one side, but it was so high that it
will continue. So you see the pattern repeating every two time steps. So while that is enough to
observe that every old time step you get is really high. You get these high sides that will take
care of further growth.
So that's how we prove this square. Now we go to the octagon. And we should first look at it
again. Let's see, this is what we looked at before. I will do that again a bit slower.
So first it looks just like the diamonds. Then you see it can't grow like a diamond anymore.
Starts to look like the square. But something else happens. Some side says, hey, I can form it a
little bit further. And I get this funny sort of roof on the edges of the square. So I have another
cell automaton about that that started this summer holiday. My husband brought his Soduko
book, and I brought my notes. I was playing around. And I said this is going to look like the
octagon that I saw. This is over half a year ago by now. Took me months to puzzle out things
precisely. It wasn't as simple as I thought at first but I didn't want to give up. Now we have a cell
automaton with 13 states and a long list of transition rules. But it works.
So let me show you the program. Instead of telling you the rules, I just programmed them. And
we can look at a demonstration. It starts from here. Why? Because I have this classes of
heights saying if the height is between this and that. Then I call it that state if it's between this
and that, I call it another state. Shouldn't be too large. Shouldn't be too small. I can't fit that in
the initial configuration with N at the origin and H everywhere else. I have to wait for eight time
steps before all the heights are in the right intervals. Then I can start. So it starts with this.
And then it grows according to cell automaton transition rules. And you may observe that the
pattern is repeating. Maybe it's not so clear as in this diamond and this square case. But have a
look at this. This tiny side pointing out. There's another one here. There's another one there.
And this little corner it repeats every two time steps.
So just wait for that one to appear again. It takes five time steps. One, two, three -- there it is
again. Now it looks a bit different. It used to be there. Five time steps ago. Now it's here. So
we proceed another five time steps. And now it looks like 10 time steps ago. But only what
happens there's one more of them.
So the pattern nicely repeats every 10 time steps, but it's another building block like this is added.
So once you have that, then it's an inductive argument. It will delimited look like huge row of
these tiles and limiting shape as an octagon. So that's how the proof works. It's a bit elaborate.
But it works.
>>: How can you write a program to construct these proofs?
>> Anne Fey: Right. I was going to get to our open problems at the end because now I've shown
you that there's lots of interesting things that happen in this tiny interval of H, that we proved a
number of times. We have three limiting shapes and time. Diamonds, square and octagon.
Maybe Eyon will figure out the order of the octagon, but I advised her not to go run too much
measuring the last few months.
But what about these other things that we saw. Is it true that in this nice interval you always find
a polygon as limiting shape? Does it depend on N or not? I chose a particular value for N to
simplify the proof that we have a feeling that for all the values of N it will be the same shape. And
what about -- what I didn't show you yet is I showed you values of H that were at least one-half
plus one-eighth plus one-sixteenth. Above that, we saw all these nice polygons. But what if we
go a little bit below that?
So I do this. I alternate. The value I get will be very close to two-thirds. Just above. And try a
demonstration. What numbers did I use? I think these.
Watch this. Oh. Sorry. Take this out. There we go. So, okay, it stops. You can see here H is
.667. It stops when it stops it has to be a square. That we know. And I increase N a little bit.
You see it's not acting as predictable as it did just a moment ago. And you can definitely tell it's
not going to be described by a cell automaton. And even am not sure if this thing is going to have
a limiting shape at all. It seems to change shape all the time.
It looks a bit squarish at the moment but it will look a bit different sometime later. I think you saw
before that at some point it decided to almost to be a sphere and it turned square again.
>>: How do you know it's not a cell automaton in 2006?
>> Anne Fey: That's good how could that be possible? But, okay, there's more worries. Not so
simple as it seemed just a moment before. I chose this value very close to two-thirds for a
purpose. We actually think that there is a threshold value, exactly two-thirds. That above
two-thirds it's explosive and below it is robust.
So I go through that value here that we can prove. It's more than two-thirds in dimension. It's 7
over 10. And the method it can get a little bit closer. It can prove .783. But it's still not two-thirds.
But based on the simulations we are convinced that it is two-thirds.
So we don't know why. As I showed before, there's another additional problem with defining a
threshold H once you find a particular value of H, there, it's explosive. You're not even sure about
the next, the one that is slightly higher. Because it's the model is not monotone.
So that's what I wanted to conclude with. Nice model. Nice results. Much more open problems.
[applause]
Everything must have been completely clear.
>>: I think we're all fascinated by the [indiscernible].
>> Anne Fey: It's pretty that it gets slow.
>>: Do you see -- what's the [indiscernible].
>> Anne Fey: I'm sorry?
>>: One time it looked like it was smashed together, the program. Is that ->> Anne Fey: Want to stop this and look at the other one?
>>: More than 12 sides.
>> Anne Fey: Oh. Possibly. I wrote on this other value because it looks nice. So should I try
another one?
>>: Okay.
>> Anne Fey: What was it? One-16th. I thought this one looked nice but I don't exactly
remember what it was. Okay. You tell how many sides it has. Is it an octagon? So I thought this
one looked nice. But I didn't really look into it.
>>: How about the heights on the inside or time function describes the height.
>> Anne Fey: These inserts?
>>: So far only looked at the boundary, because that's where the shape is determined.
>>: Is it much different in the center from the pathway?
>>: There's something showing in the picture.
>> Anne Fey: The height is not constant. It's this sort of star-like pattern that you see. It also
changes over time. So I think it's more a more constant as time progresses.
>>: So the star is higher or ->> Anne Fey: Higher. No? Lower. Sorry. Here's the color code. So orange is higher than
yellow.
>>: But what are the units, the heights are actually 40 or 50?
>> Anne Fey: No. Print height times 60. No, times something. To make it come out nice.
>>: Slack is empty?
>> Anne Fey: Yes.
>>: Heights are, what, they're a little more than one? The yellow.
>> Anne Fey: This is almost two. So I think print height times 30.
>> David Wilson: Any further questions? Let's thank Ann again.
[applause]