In the previous segment, we saw how functions can be concealed behind or inside black boxes,

how we can infer them by performing experiments such as perturbing them and making the corresponding observations.

Well, functions can also be seen as computer programs.

As we had said before, the identity function, for example, can have an infinite number of

implementations. For example the simplest version is just f(x) = x.

And it will look exactly the same as f(x)

= x + a - a from the perspective of an observer feeding the input and watching the output.

And versions of the same function can be very complicated.

If one only cares about the output, then functions may be enough as the object of study but if we care about mechanisms,

then other type of time dependent equations and computer programs are better representations.

Representations that have a time variable are traditionally the object of study of an area called dynamical systems.

A cellular automaton is a type of discrete dynamical system that we will be using along the course.

One intuitive way to explain what a cellular automaton is, is to look at the way they work with what we call their

space-time diagrams. In a spacetime diagram,

one of the simplest cases of cellular automaton, called elementary cellular automata, as introduced by Stephen Wolfram,

time runs from top to bottom

starting from an initial tape placed on the top.

Cellular automata run on a discrete space that looks like a Sudoku grid.

One may start the system with a black cell and then apply a set of local rules from top to bottom row by row.

The set of rules are also called a rule icon.

The rule icon of a cellular automaton dictates how each cell changes over time.

You can see that the rule that corresponds to the initial black cell surrounded by white cells is a

new black cell in the second row and so on.

This particular example

illustrating how a cellular automaton works is slightly

misleading because each row should be updated in parallel. In contrast, in this example, the cells highlighted in red

show the local rule that was applied at each step sequentially so that you can follow how it works.

A cellular automaton has the advantage to be a

highly visual computer program whose evolution can be inspected and followed step by step in real time. In other words,

it's some sort of transparent computer program that allows to understand every single piece

visually to be tracked down at the lowest scale.

It is a deterministic system and thus causal so it will play an important role in our

computational approach and exploration to causality.

Notice that time can be seen as flowing from top to bottom while space runs

to the sides. this is why the diagram is called

space-time diagram and it provides a two dimensional view of the evolution of a one dimensional discrete dynamical system.

Notice also that one can also

start from a less simple initial configuration rather than a black cell, for example from a random initial

configuration. Yet the rules are applied in exactly the same fashion.

A minor technicality is what happens at the borders of the system because each role is defined in this case every three cells.

But at the beginning and

end of the system, both right and left extremes, one cannot evaluate the last two cells without a third neighbor.

So what do we do?

By convention, what it is done is to take the missing cells from the opposite sides as you can see from the example.

Cellular automata can be seen as part of a larger type of ways to simulate

aspects of causal reality with what is known as an agent-based approach

given that individual cells can be seen as agents interacting with other agents according to some specific rules.

Agent based models and cellular automata are bottom-up approaches for constructing models of causal phenomenon.

Cellular automata can be studied as black, gray, and transparent boxes for purposes of testing old and designing new tools.

Cellular automata are traditionally completely transparent boxes as I have said before, as they are very visual in the form they evolve.

But as we have also seen this is not always the case in the real world.

So, if you are an ideal observer you would probably witness the whole space-time diagram running and if sufficient

observations were possible the rule icon could be cracked.

That is, the computer code and generate generating mechanism for a particular cellular automaton.

So a cellular automaton is an ideal

simplification on which ideas related to causality can be studied.

By, for example, concealing the cellular

automaton evolution to see what an observer looking at the last output can infer about it.

We can perform some sort of organized attack on this particular cellular automaton black box to see if we can crack the code.

The strategy will consist in giving it an ordered set of initial conditions based on a binary

enumeration and then see what the cellular automaton may be just as we did with mathematical functions by looking at the output.

It looks like for any input,

as marked in red in the example, the output is always blank so the rule icon must be something that takes

any input and then writes a white cell if this is an elementary cellular automaton.

That rule is called rule 0

because the output is all white cells and taken as if they were zeros in binary they would represent the zero in decimal,

that is, Wolfram's enumeration scheme for elementary cellular automata.

However, not all rules are so simple.

There is a so-called

elementary cellular automaton with a rule 30, which is called rule 30 again, because its binary

representation of the output is 30 in binary. Its evolution as depicted from

steps 1 to 70 looks quite random has even been used as a random number generator in the past.

Trying to crack the code by only observing the last row at rule 30

is much more difficult than the previous examples and one has to perform the observations in the right place to avoid being misled

given that the rule actually represents some regularities in certain places.

A simulation is, by definition, a series of causally connected events, a determinstic evolving system that we call a dynamical system.

We will see in the next modules how we can model and simulate evolving systems and not only

crack their generating codes from partial observations, but also how to reconstruct these systems from disordered

observations and then even reprogram them to perform different computations and behave in different ways.