So, now that we've introduced the projection operator, let's see where we are. We began with the original evolution law of the fine-grained cellular automata f(x, y, z). We then realize that if we wanted to skip two time steps in the future we would have to have more arguments here. So we rewrote that as f hat as a function of x hat, y hat, and z hat. What this function does is it takes the state of the system here and evolves it two steps forward. Instead of writing each of these grid cells separately we write them as a combined variable x hat, y hat and z hat. Now the relationship between this f and this f hat here is totally is totally deterministic. Once you tell me this I can work out this here. The problem is is that this f hat is no longer in the same model class as this. All I've told you is that when you coarse-grain in time, you get a different model. But there's really no good way to relate these to say like oh this has become more or less complex, this has become more or less interesting, this parameter has changed. We can't for example place these as dots in some phase space and show, how models move as you coarse-grain them in time. But now we have the projection operator and so we can write something like this. We can project down the input supercells. We can coarse-grain the spatial state of the system, and then we can talk about the function g that evolves these coarse-grained variables forward in time. So, we can think about these two different operations on a diagram that you can imagine as, well, it's sometimes called a commuting diagram. Down here, we have the fine-grained system state specified by three variables x hat, y hat and z hat. And of course these variables here expand if you wanted to into a list let's call them x_i's, i from one to six for that little patch of the cellular automata. So this is at time t equals one, then we can get the fine-grained system at time t equals two. And then we can get the fine-grained system at t equals three. With the projection operator I can take this set of system states here and map them to a set of projections p hat or p of x hat, p of y hat and p of z hat. And then I can evolve that coarse-grained system forward using some function g. Now what g does is it takes in three binary variables and spits out a single binary variable so g is somewhere in the model class of cellular automata, and out the other side I get a new set of variables or rather I get the evolved state of the system at the coarse-grained level. From here to here we just require f and f, we wrote down this function f hat that gets you there it takes all these variables in at once and so f hat takes x hat y hat and z hat. And so going along the bottom we evolve the supercells. Going up we project the initial configuration of the supercells. Going right up here we evolve that projected configuration forward in time. And so now we can compare what happens if you coarse-grain and evolve to what happens if you evolve and then coarse-grain. So our goal now will be given a particular cellular automata, f at the fine-grained level, can we find a projection operator p and a coarse-grained evolution operator g such that if you go along this path it's equivalent to going along that path? In other words, can we make this diagram in the technical language, commute? Notice that this function here g takes in three binary variables and spits out a single binary variable and so it is in fact in this same CA [(Cellular Automata)] model class that is indeed one of the 256 of the cellular automata that we can think about to begin with. If we go with this projection operator here it may even be the case that we can find a p such that the g that makes this diagram commute is is equal to the f. In other words if we skip a step and blur the spatial dimension in the right way we may actually get back the same evolution operator. It's a little bit like saying If you zoom out and squint do you get back the same process with which you began?