As an archaeologist, I am interested in long-term change and how it works. Given the current multiple situations around us at the moment, it isn’t surprising that I have been increasingly thinking about sudden change in particular, and why it sometimes seems to come out of nowhere. One of the answers is that we live in a complex system, or perhaps at the intersection of several different complex systems, in which sets of simple interactions between sets of simple elements combine to create complex and unpredictable patterns.
We often think of ourselves, as humans, and of our societies, as complicated and difficult to understand and predict. I have long suspected that this is a very human conceit. The more I consider human history and the archaeological record, the stronger is my impression that when we say that our world and our societies are complicated, we really mean that we are not in control.
This is why, no matter how hard we try, sometimes we just can’t get things to work the way we think they should, as individuals and as groups. The simple processes that surround us, rather than our intentions and actions, are the main source of patterning in our lives.
RGBCatastrophe is a very simple tool for starting to think about this stuff. It can help students understand the basic insight that a single kind of cause can have a broad range of impacts, depending on the context in which it happens, and the related insight that simple interactions between a few elements can generate complex and unpredictable behaviour. It can help us understand how system state relates to consequences and how rapid and sudden change can take place.
Feel free to use it and modify it to your liking. As a bonus, you can use it to create interesting procedural graphics and some interesting soundscapes (see the full guide below). It can certainly use many improvements, and probably some fixes, but it’s a start.
To use it, simply download and install Netlogo, download the file linked below, open the file, click setup, and click go.
Download NetLogo (northwestern.edu)
## RGBCatastrophe 1.13 Guide
Andre Costopoulos
University of Alberta
30 May 2022
RGBCatastrophe is a small teaching and reflection tool that you can use to explore self-organized criticality and systemic change. It is based on the classic sand pile model.
It generates up to three sand piles (or sand scatters of various radius) on a table and tracks the number of patches impacted when sand is added to the system. Each sand pile or scatter is independent of the others (they don’t interact), but the combined impact of all three on each patch is tracked.
There are a number of inhabitants (or observers) on the table who are aware of the impacts around them, and the system tracks what they are aware of relative to what is happening on the entire table. You can use it to explore complexity, think about different kinds of systemic change. It can also just make nice procedural graphics or even soundscapes, if that’s what you like.
It can help students understand the basic insight that a single kind of event or cause can have a broad range of impacts, depending on the context in which it happens. It can help us understand how system state relates to consequences and how rapid and sudden change can take place in apparently stable and predictable systems.
Hopefully, it’s also just fun to explore.
## Interface
Buttons and selectors
The Setup button resets the table and puts three grains of sand on it (a red, a green, and a blue).
The Go button starts the simulation, using the parameters set in the sliders (see below).
DisplayType has three different modes:
“All” shows the amount of each kind of sand on each patch. The redder the patch, the more red sand it has on it, for example.
“Impacted” shows only the patches impacted as each grain of sand hits the table. It can help you see when and where there are avanlanches.
“Critical” shows how close the patch is to the critical value relative to its neighbours. For example, if the critical value is 10, and a patch’s red value is 15, and it has a neighbour with a value of 6, it will be very near criticality (difference of 9) and will show a strong red component.
If the ShowImpact switch is set to ON in the “All” dispaly mode, impacted patches will light up red, green, or blue as appropriate. This is helpful in some situations, but slows down the simulation quite a bit.
ShowImpact is also useful for tracking the spread of a pile after a change down in critical value. But be warned, this can make for a very slow time step.
Setting Sound to ON provides sound cues for some of the events in the simulation. Each time there is a new largest avalanche to date for a particular colour, there is a louder sound (Red = snare drum, Green = cowbell, Blue = cymbal), and there is a soft sound each time a patch is impacted. By turning on the sound, you can get a sense of what is happening on the table. Different settings will produce different soundscapes.
Parameter sliders
The Change Probability slider controls the probability (out of 100 000) that there will be a change in one of the system parameters (increments values and critical values).
Change Magnitude slider controls the size (out of 100) of any change to one of the system parameters (increment values and critical values).
The rConstrain, gConstrain, and bConstrain control the tightness of the respective sand piles. A constraint value of 100 will drop new grains on one patch only (always the same patch), while a constraint value of 0 will drop new grains anywhere on the table.
The rIncrement, gIncrement, and bIncrement sliders control the number of grains of each colour that are dropped at each time step.
The rCritical, gCritical, and bCritical sliders control the critical value for each colour of sand. When the number of grains of sand of a particular colour on a patch exceed the number on one or more of its neighbours by more than the critical value for that colour, the sand from that patch tumbles onto its neighbours. For example, if a patch has a red value of 20, one of its neighbours has a red value of 15, and the critical value is 4, one grain will tumble from the patch onto its neighbour (20 – 15 = 5, which larger than the critical value of 4. After one grain has tumbled, the difference will be 19 – 16 = 3, which is smaller than the critical value of 4). You can think of the critical value as the maximum angle or steepness between two patches that can exist in the system. A high critical value allows for a very steep pile with episodic spread, while a low critical value makes for a pile with a gradual slope and gradual spread.
PopCount controls the number of inhabitants (observers) on the table. Note that changes in PopCount only take effect when you press Setup for a new run. Changing PopCount in the middle of a run will not add inhabitants.
InfoReach controls how far the inhabitants can see. It is the radius (% of the total area of the table), of which they are aware.
Graphs
Combined Impact shows the number of patches impacted by all drops (up to three) at each time step. If a red grain impact 4 patches and a green grain impacts 8 in one time step, the graph will show an impact of 12.
Relative rImpact, relative gImpact, and relative bImpact each show the impact of their colour sand relative to the largest value so far. If the largest impact for dropping a red grain so far was 8 patches, and the current drop impacts 6 patches, Relative rImpact will show a value of 8 / 6 = 0.75. If the current drop impacts more patches than the previous largest one, it becomes the largest and the graph shows a value of 1.
Impact Awareness shows the impacts sizes of which the inhabitants are aware, given their InfoReach. Grey line shows the maximum number of impacts that any inhabitant is aware of, and the black line shows the number of impacts that the average inhabitant is aware of. Both lines show their values as a percentage of total impact for a particular time step.
NetLogo controls
If you click on the setting button at the top of the window, you can set the size and resolution of the table. This is helpful if you are running with less (or more) computing power. For a quick sim even on a laptop, set max-pxcor and max-pycor to 50, and patch size to 4. This also helps with making the dynamics quite visible.
If you have more computing power, if you don’t care about execution speed, or if you are just looking to create a nice piece of procedural digital art, go big on max-pxcor and max-pycor, set patch size to 1, and leave it overnight, or for a few days, or whatever.
If you don’t want the table to have edges, you can turn on world-wrapping, horizontal, vertical, or both. By default, there is no world wrapping and sand piles against the edge of the table. Think of it as a sunken cube.
## Experiments
The classic sand pile
This experiment just shows the basic functioning of a sand pile. It adds one grain of sand at a time onto one pile. The pile gradually builds up. Most of the grain drops affect only a few patches by displacing other grains. Sometimes, the sides of the pile collapse and a larger number of patches are affected. This is an avalanche. It is an episode of relatively rapid and sudden change.
Note that nothing in the system changes to cause a catastrophe. There is still just one grain of sand being dropped on the same pile, one at a time. What changes is the organization of the pile itself. The single grain of sand is dropped on a pile that is critically self-organized, and that starts the avalanche. The lesson here is that large, infrequent kinds of changes are not necessarily due to large, infrequent kinds of causes.
The same old things that happen every day can have very different kinds of impacts, depending on the context in which they happen.
Parameters:
Change Probability 0
Change Magnitude 0
gConstrain 100
rIncrement 0
gIncrement 1
bIncrement 0
gCritical 1
Parameters that are not named above are not used, so you can leave them as they are. I chose green for this one, because on many displays, especially laptops, it is the most visible.
These settings generate a single sandpile (green). For this first experiment, hit setup and go until you get a pile that is not too near one of the edges. You can explore edge effects in later experiments.
One grain is dropped on the pile at each time step. Since the critical value is 1, grains tumble down the pile as soon as there is a difference of 2 between two adjacent patches. When the first grain drops, there is a difference of 1 between the centre patch of the pile and its neighbours. When the second grain drops, on the pile, there is now a difference of 2, which exceeds the critical threshold, so one grain will tumble onto a neighbour, giving it a value of 1, and leaving 1 at the center of the pile. Because the neighbour that received the grain now has a difference of only 1 with its own neighbours (or a difference of 0, in the case of the patch at the centre of the pile), there will be no further tumbling at this time step.
The spikes on the Combined Impact graph and the Relative gImpact graph show that the pile is fairly stable until it reaches a critically self-organized state. At first, each drop of a grain of sand impacts just a few patches around the drop site (centre of the pile). Eventually, many patches become critical relative to their neighbour, and a single drop of a grain will cause a collapse, or a reorganization of the pile, and will affect a large number of patches. That’s when there are spikes on the graphs.
The collapse is followed by a period of stability while the pile rebuilds toward a critically self-organized state.
Once the pile is large enough to get good visibility, select the Impacted display type. In this mode, the patches affected by each drop will light up (shade will be proportional to their green value). During periods of relative stability, when few patches are affected by each drop, just a few patches will light up at each time step.
When the pile reaches SoC, a collapse will begin, the graphs will spike, and the display will start looking like a spider at each time step, with lots of patches being affected at once. When the collapse episode has settled, the display will go back to lighting up just a few patches at each time step.
If you select the Critical display type, you will see that there is not much variation in shade on the pile. That is because the critical value is 1, and so even when the pile is near SoC, the difference in criticality is small. While there are catastrophes with these values, the pile grows in a relatively smooth and orderly way.
Reflection questions: Why do the spikes on the graphs get higher over time? Why do the intervals between spikes on the graph seem to get longer over time? How would this affect the inhabitants of the sand pile if their life span was constant over time?
Exploration: Increase gIncrement. What happens to the dynamics of the pile?
Multi-dimensional complexity
In real life of course, there is not just one kind of event affecting us. There are lots of different kinds of things happening. What happens if we are affected by different kinds of complex processes that can each cause avalanches or catastrophes? Do they cancel each other out to create a noisy world where we see no pattern? Do they combine to generate mega-catastrophes?
Parameters:
Change Probability 0
Change Magnitude 0
rConstrain 100
gConstrain 100
bConstrain 100
rIncrement 1
gIncrement 1
bIncrement 1
rCritical 1
gCritical 1
bCritical 1
Don’t forget to hit the setup button before after you adjust the parameters.
These settings generate three distinct sand piles that are all independent of each other. They don’t interact. Sands of different colours (red, green, blue) do not touch and cannot interact.
So in effect, you have three of the classic sand piles with which you experimented in the first exercise. They all behave as that one did. They will combine to affect more patches per time step. Since they start accumulating at the same time and in the same way, they will initially be fairly well synched and will tend to reach SoC at the same time and generate large spikes on the Combined Impact graph.
As time passes, you may notice that the three relative impact graphs get out of phase to each other. This can happen relatively quickly if at least one of the piles is very near an edge, for example. The piles diverge when two of them are very close to an edge. Blue and green are fairly well aligned for the whole run, but red starts spiking at relatively odd times after it encounters the edge at mid-run. Note that in this version of the sim, the sand does not fall of the edges. Rather, it piles up against them.
Exploration: Now try the same experiment, but set rIncrement and bIncrement to 0 initially, so that only the green pile is growning. Let it go for a few thousand time steps. Then set rIncrement to 1 so that the red pile starts growing and let it go for a few thousand more. Then start growing the blue pile as well. What happens to the pattern of avalanches?
Reflection questions: From the point of view of an inhabitant of the table, what happens if sand piles start to overlap? Given different life-spans and visibility ranges (i.e. how much of the able is an inhabitant aware of at one time?) how does the experience of an inhabitant change as the piles grow?
Changes in environmental regime: increment vs criticality
The two main factors that affect how the sandpile behaves are the increment value and the criticality value. The increment value controls he number of grains of sand that are dropped on the pile at each time step. The more grains are dropped at once, the faster the pile grows.
The criticality value affects the steepness of the pile. If the value is set to 1, then as soon as there is a difference of 2 grains between two adjacent patches, one grain will tumble from the more crowded patch onto the neighbour. If the value is set to 10, the difference has to be 11 before there is any tumbling down the pile. The higher the value is, the steeper the pile can be.
What happens if we change those values mid-simulation?
Parameters:
Change Probability 0
Change Magnitude 0
rConstrain 100
gConstrain 100
bConstrain 100
rIncrement 1
gIncrement 1
bIncrement 1
rCritical 1
gCritical 1
bCritical 1
The classic demonstration of complexity is that a single type of event (e.g. a single grain of sand hitting a sand pile) can have very different impacts, depending on the context in which it happens. A single grain of sand can have a very local impact, or it can cause a global catastrophe. The insight we get from this is that we shouldn’t always look for extraordinary causes when we see extraordinary consequences. Sometimes, we need to look at the state of the system in which a normal cause happens.
In the real world, of course, there are different kinds of events as well as different kinds of consequences. What happens to our system if one of the kinds of events is a change in a parameter of the system itself? In other words, what happens if our constant event (the dropping of a grain of sand), happens in an environment that is also slowly changing?
Start the simulation and let it go for a while, maybe a few hundred time steps so you get a nice graph going. Now stop the simulation and increase gIncrement to 10. Start the simulation again. The Combined Impact graph will change quite a bit.
This is normal, because you are now dropping 10 grains of green sand on the table at each time step instead of just one, so more patches are affected by each drop. The green pile is now spreading much faster than the other two.
But after jumping, the graph remains pretty much where it is. We now have a new normal developing. From the point of view of an inhabitant of the table, there was a sudden change, but it is followed by a new form of stability. We can think of these kinds of changes as changes in environmental regime.
Let it go for a while, and then stop the simulation again. Bring gIncrement back down to 1. There will be another sudden change in the impact graph, but a new normal develops again.
Reflection: When you bring gIncrement back to 1, does the impact graph go back to where it was before you increased it? Why, or why not?
If we change the criticality value, something very different happens. Stop the simulation and increase gCritical to 10. Let the simulation go for a few hundred time steps at least. Now stop it again and decrease gCritical back down to 1. Start the simulation. What happens to the graph? Why? Can you think of real-world phenomena that behave like this? If you want to see the pile collapse in more detail, set ShowImpact to ON, but be ready for a long time step, especially on slower computers. It can be fun to watch though.
Experimenting with change
Parameters:
Change Probability 50
Change Magnitude 5
rConstrain 100
gConstrain 100
bConstrain 100
rIncrement 0
gIncrement 0
bIncrement 0
rCritical 1
gCritical 1
bCritical 1
With the above parameters, nothing much will happen when you start the simulation, because all three increment values are set to zero. There is a 50/100000 probability that there will be a change of up to 5 in each of the increment and critical values at each time step. So let it run for a while and eventually, one or more of the increment values will go up and sand will start to drop on the table.
Eventually, the critical values will change, and the dynamics of the system will start to create changes in regime, and catastrophes big and small.
Freeing up the table
Parameters:
Change Probability 50
Change Magnitude 5
rConstrain 0
gConstrain 0
bConstrain 0
rIncrement 1
gIncrement 1
bIncrement 1
rCritical 1
gCritical 1
bCritical 1
With the above parameters, sand grains don’t drop into a single neat pile. They can drop anywhere on the table. There can be changes in environmental regime and catastrophes. Let it evolve. Watch it for a while. Think about what the graphs mean.
Adding inhabitants
Parameters:
Change Probability 50
Change Magnitude 5
rConstrain 100
gConstrain 100
bConstrain 100
rIncrement 1
gIncrement 1
bIncrement 1
rCritical 1
gCritical 1
bCritical 1
PopCount 50
InfoReach 25
For now, we’re going back to some simple sand piles, but there are now 50 inhabitants on the table who will be aware of any impact within a radius equal to 25% of the total surface area.
When you start the simulation, you will note that the total impact (black line) is almost always larger than the biggest impact any inhabitant is aware of (brown line), and generally much larger than the impact of which the average inhabitant is aware of.
In other words, there are usually much bigger catastrophes going on that anyone is aware of, and most people are not aware of the extent to which some others are experiencing catastrophe. Think about that for a while, then start experimenting with the parameters to see who it affects the experience of inhabitants.
ArcheoThoughts 