2.14. Lecture 13: Self-organized criticality

Before this class you should:

• Read Think Complexity, Chapter 8

Before next class you should:

• Read Think Complexity, Chapter 9

Note taker: Ken Phanthavong

2.14.1. Critical Systems

A critical point is a point in a system where it is in-between states. This in-between state is often called the critical state. Systems under a critical state are called critical systems.

Most systems require a parameter that changes the state to be tuned precisely to reach a critical state. When a system has self-organized criticality, the system will tend toward a critical state on its own without the parameter being tuned.

2.14.2. Sand Pile Model

The first example of a model that showed the behavior of self organized criticality was the sand pile model by Bak, Tang, and Weisenfeld. The sand pile model is not meant to realistically simulate the behavior of sand piles, but to show the general behaviors of systems with large numbers of interacting elements and critical systems.

The sand pile model is a 2D cellular automata model where each cell is the slope at that location. When a cell exceeds some threshold slope, the sand topples and transfers one unit of slope to each of the neighbouring cells. Single grains of sand are dropped at a time to perturb the system. When a perturbation causes one or more cells to topple, it is called an avalanche.

The following implementation of the sand pile has the constructor set all the cells to an equal level.

class SandPile(Cell2D):

    kernel = np.array([[0, 1, 0],
                       [1,-4, 1],
                       [0, 1, 0]])

    def __init__(self, n, m, level=9):
        self.array = np.ones((n, m)) * level

The step() method topples all cells above the threshold and distributes its value to its neighbours. The run() method calls the step() method continuously until there are no cells left that can be toppled (when it reaches equilibrium).

def step(self, K=3):
    toppling = self.array > K
    num_toppled = np.sum(toppling)
    c = correlate2d(toppling, self.kernel, mode='same')
    self.array += c
    return num_toppled

def run(self):
    total = 0
    for i in itertools.count(1):
        num_toppled = self.step()
        total += num_toppled
        if num_toppled == 0:
            return i, total

The drop() method adds a value of 1 to a random cell.

def drop(self):
    a = self.array
    n, m = a.shape
    index = np.random.randint(n), np.random.randint(m)
    a[index] += 1

Here is an example of initializing and running a sand pile until it reaches equilibrium. The level set to every cell is 10 in a 20x20 cell grid.

pile = SandPile(n=20, level=10)
pile.run()

The sand pile in equilibrium.

2.14.3. Heavy-Tailed Distribution

Critical systems have heavy tailed distributions in some of their properties. Sometimes these follow the power law, which is a type of heavy tailed distribution that is scale invariant.

The distribution of a sand pile model can be shown to have a heavy-tailed distribution in its avalanche size (S) and duration (T). This can be measured by performing many random grain drops and calculating the probabilities of avalanche sizes and durations.

pile2 = SandPile(n=50, level=30)
pile2.run()
iters = 100000
res = [pile2.drop_and_run() for _ in range(iters)]
T, S = np.transpose(res)
T = T[T>1]
S = S[S>0]
pmfT = Pmf(T)
pmfS = Pmf(S)

Probability mass functions of sand pile avalanche size and duration.

Probability mass functions of sand pile avalanche size and duration on log-log scale to show power law similarity.

2.14.4. Fractals

Another property of critical systems is that they often result in fractal geometry forming. This can be shown in an initialized sand pile under equilibrium. The CA looks like it has fractal patterns.

pile3 = SandPile(n=131, level=22)
pile3.run()

Sand pile in equilibrium showing fractal-like patterns.

Under equilibrium, there are only 4 levels in the sand pile CA: levels 0-3. The fractal patterns and dimensions can be found for cells at each level.

def draw_four(viewer, levels=range(4)):
    thinkplot.preplot(rows=2, cols=2)
    a = viewer.viewee.array

    for i, level in enumerate(levels):
        thinkplot.subplot(i+1)
        viewer.draw_array(a==level, vmax=1)

Levels 0-3 of the sand pile from the top left to the bottom right.

The bounding box method is used to measure the amount of cells in a growing box on the sand pile. The fractal dimension can be estimated with the number of cells for each box size.

def count_cells(a):
    n, m = a.shape
    end = min(n, m)

    res = []
    for i in range(1, end, 2):
        top = (n-i) // 2
        left = (m-i) // 2
        box = a[top:top+i, left:left+i]
        total = np.sum(box)
        res.append((i, i**2, total))

    return np.transpose(res)

res = count_cells(pile.array==level)
steps, steps2, cells = res

Fractal dimensions of levels 0-3 of the sand pile from the top left to the bottom right.

2.14.5. Pink Noise

\(1/f\) noise, also known as “pink noise” is a type of behavior present in signals of critical systems. Signals are properties or quantities that change with time. These signals can be represented as the combination of sinusoidal waves/functions with different magnitudes, essentially breaking them down into different frequencies with different strengths. These strengths or magnitudes are also called power, and a power spectrum is a function that shows the power at each frequency. The power of pink noise is equal to \(1/f\), \(f\) being the frequency.

The Welch method implemented in the SciPy function calculates the power spectrum given a sequence of values and the time between each value, nperseg. The power spectrum is plotted for the number of toppled cells of the earlier sand pile.

from scipy.signal import welch

signal = pile2.toppled_seq
nperseg = 2048
freqs, spectrum = welch(signal, nperseg=nperseg, fs=nperseg)

Power spectrum of the number of toppled cells from grain drops on a log-log scale showing relation to pink noise.

2.14.6. Reductionism and Holism

Holistic Model

• Focuses on similar behaviors in different systems

• Contains only the elements necessary to describe those systems

Reductionist Model

• Focuses on realism

• Describes the fundamental parts of a system and their interactions

The sand pile is meant to simulate a behavior that appears in many systems that show self-organized criticality. Self-organized criticality is a holistic model of naturally occurring critical systems.

2.14.7. Causation and Prediction

Self-organized critical systems may not have a specific cause for rare and unexpected events since they contain heavy-tailed distributions. Instead, it could be naturally occurring as a property of the system as a whole rather than a specific interaction. This means that they are fundamentally unpredictable and unexplainable.