Iterating Determinate Functions

If you take a purely determinate function and iterate it over time difficult-to-predict behavior can emerge.  If  you only use the same function, then the outcome is easily determined and therefore not complex.  But if you use more than one determinate function or a set of rules with simple determinate functions then difficult-to-predict behavior may emerge.

Iterating only the exact same determinate function

Difficult-to-predict behavior won’t emerge simply by using the exact same function over and over again.  If the basic function is a multiplication function:

determinable multiplication.png
… and you use the output from the first iteration as the input for the next:

Output from each function is used as the input for the next step.

… and each step’s output can be easily determined using the following equation:

(original input) * 3^(desired step)

So if I want to know the state of the system with an original input of 5.6 at step 134, for example, it is easy:

(5.6) * 3^(134) = 4.81e64

So we can see that this system isn’t very complex.  We can easily determine the state of the system at any past, present, future, or hypothetical case without stepping through the entire iteration.

Another type of function uses rules.  Imagine a row of blocks.  The color of each block is either blue or gray.  There are eight blocks, and the color of each block is the initial input to the system.  Here is an example:

Each block is 32×32 pixels

For each step in the system, each block will follow this simple rule:

Make your color at step+1 be the color of the block to your left.

So the next step would look like this:

Step 1

And the next step would look like this:

Step 2

So over time, the animation would look like this animated .gif:

“Make your next color the color to your left” iterated.

With a different starting input, it might look like this:

But even these examples are not complex.  The color of each block at any step can be easily calculated from the initial input without stepping through the entire system.

Iterating combinations of determinate functions

Once you start combining different determinate rules or functions over time, however, the values of a system at a given point may become difficult to predict and you may start to see complexity.  Not all combinations of rules and functions will result in complexity.

Let’s take another example of the colored blocks and apply these rules for color:








  • If the blocks to your left and right are the same color, become that color (majority rules)
  • If the blocks to your left and right are not the same color, become the next color that the block to your left will be (no majority, follow your left neighbor)
  • If the blocks to your left and right are the same color, and that color is your current color, and the block to your left is also that color, become the opposite color (overcrowding leads to opposite behavior)
  • If you are the left-most block in the group and the blocks to your left (wrap-around) and right are not the same, don’t change color (no majority)
  • If you are the left-most block in the group, ignore the overcrowding rule


Here are a two runs using these rules:

The color of any block at a given point in the system is difficult to predict, but not just any combination of rules will yield these types of results.  Notice that the rules for these two systems:

  • inputs that are taken from previous outputs (the actions of other blocks have an effect on each other)
  • use positive feedback (majority rule)
  • use negative feedback (overcrowding)

Simple functions that result in complexity

There are some simple functions that, when iterated without end, result in solutions that can’t be determined from the outset – that is, you have to step through each iteration to determine the resultant value of the function at any given step.  Here are some examples.

Mandelbroit Fractal

Benoit Mandelbroit has been working with complexity since the 1970’s. The Mandelbroit set is famous for the fractals it creates:

The set is expressed:
z² + c

The Logistic Map

Used to describe population growth, scientists and mathematicians found that at certain values, this equation demonstrates peculiar behavior:

where is the carrying capacity of the population and is a combination of birth and death rate.  At certain values for and , you might get something that looks like this:


Certain combinations of simple determinate functions or rules will produce complex behavior.  You cannot use the same determinate function over and over again because the outcomes can all be predicted easily.  For complex behavior or emerge, you have to use different variations of that function or use different functions.

Citations to this discussion:

One thought on “Iterating Determinate Functions

  1. Pingback: Games for Complexity Lovers: Conway’s Game of Life ⊆ Complexity Basics:

Leave a Reply