So this week we spend a lot of time
on elementary cellular automata, or elementary CA,
and next week, we'll start building our own models using
more spatial dimensions, stochastic rules,
more states for the cells, but I wanted to give you
a little fun preview of really the kind
of complexity that can emerge from spatially explicit models
beyond what we can do with elementary CA,
and so, I said it in the very first video,
if anything, what cellular automata are really good
for is illustrating this idea that the whole
is more than the sum of its parts
and that you have emergent behavior.
What do I mean by that, by that flowery language?
Where really, when you look at the rule set
of an elementary CA, it's really,
really hard, unless you've seen it before,
to determine what kind of behavior is gonna come
out of that model at a global scale,
and so it shows how complexity can emerge
from deterministic, simple, local rules.
Now, I wanted to give an example
of how quickly that complexity can grow,
and that's Conway's famous "Game of Life" model,
and so while this video plays, you'll get an introduction.
It's a binary CA in two dimensions,
so each cell is, they're alive or dead, a one or a zero,
just like we saw in elementary CA,
and the model takes place on an infinite,
two-dimensional grid, and every cell interacts
with each of its eight neighbors.
So the diagonals top-down, left-right,
which we'll see next week is called the More Neighborhood,
and so that's a lot of rules by the way, right?
So that's nine cells total, and
so we'll use coarse grain rules,
like the ones you're seeing on screen,
to describe the system, right?
So with too many alive neighbors,
you die as if by overcrowding.
With enough alive neighbor in a dead cell,
you can create life through reproduction,
and as we saw in the first rule, if you're alive
with no alive neighbors, you die because you need,
you know, some neighbors to sustain you,
and so we see, like, extremely interesting behavior come
out of these very simple rules,
and I wanted to stress, in the elementary CA,
we saw that we had 256 models.
That came out of the size of the rule set.
Well, here, really, with nine cells, the rule set
for binary CA with nine cells in
each neighborhood is 512 rules,
so we need to specify 512 numbers to set our model.
So how many models are there for binary CA
with a rule set of size 512?
Well, two to the 512 is 10, oh, no, it's two to the 154.
That's more than the number of atoms
in the universe squared, right?
There's an incredibly rich diversity of models that you
can create in two dimensions even with binary states,
and so it's no surprise that incredibly complex
can exist somewhere in that very, very large space,
very, very complex models and behavior
in an otherwise large space where
most models are probably boring.
As we see, like, output of this model
that look very much like living machine,
I think it's important to explain
that this is an infinite grid, right?
So if you think about the number
of parameters needed to initiate a simulation
like this, it's essentially infinite.
Remember that in dynamical systems,
we had to specify our initial conditions,
just like extra parameters, in order to be able
to run the model where this is no different,
and in two dimensions, the number of initial conditions,
the number of buttons that you get to control, is huge,
and so you get to create this really rich myriad
of behaviors out of it, and in fact,
you can show that the rules are sufficient
to give you elementary computation.
You can create four-loop, conditional loops,
and this very large space give you just enough memory
to essentially have a universal computer,
or any model that we've seen so far
could be coded in Conway's "Game of Life."
So Conway's "Game of Life" could be running Euler's Method
on the SIS Model, or on the the Lotka-Volterra Model,
helping you solve some of the assignments we've seen
in class already, and what's important
to remember at that point is that having
a universal computer does not imply
that there is something about this particular CA that gets
to the algorithmic nature of the world.
In some sense, this is no different
than inventing a new programming language,
and no one calls C++ the algorithmic nature of the world,
and so it's important to distinguish, essentially,
the computation that we run wanna run,
which is the models we come up with,
and the computers that run that computation,
and so I think this is a good place to end it.
I'll pause the video and I'll see you
in the next one where we'll explore some
of our own very complex, two-dimensional CAs.