Emergence at Five Levels

  1. Child: Have you ever watched ants? Individually, each ant is just doing simple tasks, like finding food or building their home. But when you look at the entire ant colony, something amazing happens. All the ants working together create a complex system that can find food and protect the colony. This is a lot like emergence - simple parts working together to make something more complex and interesting!

  2. Teenager: Emergence is when simple things come together and start showing complex behavior that you couldn’t predict by looking at the simple things alone. Think of traffic on a highway: each car following simple rules like keeping a safe distance, but the traffic flow as a whole can create traffic jams or move smoothly. This overall behavior is not just about the cars; it’s about how they interact with each other.

  3. Undergrad majoring in the same subject: Emergence refers to the phenomena that occur when the collective actions of individual elements result in something more complex. It is a fundamental concept in fields like physics, biology, and even artificial intelligence. For example, in biology, single cells may group together and exhibit collective behavior, leading to the emergence of complex organisms.

  4. Grad student: Emergence is a central concept in complex systems and theoretical physics. It describes how new, unexpected behaviors and patterns can arise from simple interactions between less complex components. These emergent properties are often irreducible to their components, meaning they can’t be predicted or explained solely from knowledge of the components’ behaviors. Examples range from emergent behaviors in cellular automata to phase transitions in statistical mechanics.

  5. Colleague (Fellow Researcher/Engineer): Emergence, as we encounter it in fields like complex systems, thermodynamics, and computation theory, is the manifestation of macroscopic behaviors and patterns that originate from the local interactions of microscopic components. Emergent properties are typically non-reductive and can exhibit novel characteristics compared to the system’s components. One of the major challenges in our field is understanding the mechanistic origins of these emergent behaviors and developing predictive models to describe them.

Richard Feynman Explanation

Richard Feynman had a knack for making complex scientific concepts accessible and exciting to the general public. Here’s how he might explain the concept of emergence:

Imagine you’re looking at a puzzle that’s completed, all pieces snugly fitting together to create a beautiful picture. Now, take that puzzle apart and lay all the pieces out on a table. Each piece has strange, irregular shapes and fragmented parts of the image. If you had never seen the completed puzzle, you’d find it nearly impossible to guess the final picture from looking at just one piece.

In a similar way, emergence in computer science or physics refers to the phenomenon where the ‘whole’ has properties or behaviors that are dramatically different, and often unpredictable, from the sum of its ‘parts’.

Take a computer, for instance. A computer is made of millions of transistors, little electronic switches that can be either on or off. If you look at a single transistor, it’s almost impossible to imagine that a collection of these could create a machine capable of sending emails, running complex simulations, or playing movies. Yet, when you organize these transistors in a certain way, you get circuits, and circuits can be combined to form logic gates, and these logic gates come together to create a central processing unit (CPU). Before you know it, you have a computer.

Each level of complexity, each new arrangement, gives rise to new behaviors and properties that you couldn’t have predicted by looking at the transistors alone. That’s emergence - when the whole is not just more than but also different from the sum of its parts.

Coding Example

Emergence is the concept where the whole is greater than the sum of its parts, meaning that complex behaviors can arise from simpler interactions. In terms of coding, one of the most common and simplest examples of emergence is Conway’s Game of Life.

Here is a Python implementation of Conway’s Game of Life, which demonstrates emergence:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

import numpy as np
import matplotlib.pyplot as plt 
import matplotlib.animation as animation

# setting up the values for the grid
ON = 255
OFF = 0
vals = [ON, OFF]

def randomGrid(N):
    """returns a grid of NxN random values"""
    return np.random.choice(vals, N*N, p=[0.2, 0.8]).reshape(N, N)

def update(frameNum, img, grid, N):
    newGrid = grid.copy()
    for i in range(N):
        for j in range(N):
            # compute 8-neighbor sum 
            total = int((grid[i, (j-1)%N] + grid[i, (j+1)%N] + 
                         grid[(i-1)%N, j] + grid[(i+1)%N, j] + 
                         grid[(i-1)%N, (j-1)%N] + grid[(i-1)%N, (j+1)%N] + 
                         grid[(i+1)%N, (j-1)%N] + grid[(i+1)%N, (j+1)%N])/255)
            # Conway's rules
            if grid[i, j]  == ON:
                if (total < 2) or (total > 3):
                    newGrid[i, j] = OFF
            else:
                if total == 3:
                    newGrid[i, j] = ON
    img.set_data(newGrid)
    grid[:] = newGrid[:]
    return img,

# main function
def main():
    N = 100
    updateInterval = 50
    grid = randomGrid(N)
    fig, ax = plt.subplots()
    img = ax.imshow(grid, interpolation='nearest')
    ani = animation.FuncAnimation(fig, update, fargs=(img, grid, N, ),
                                  frames = 10,
                                  interval=updateInterval)
    plt.show()

# call main
if __name__ == '__main__':
    main()

In this example, each cell in a grid follows a simple rule that depends only on the states of its eight immediate neighbors. Despite the simplicity of these rules, the Game of Life can produce a wide variety of unexpected behaviors.

This code needs numpy, matplotlib.pyplot and matplotlib.animation to work, which you can install using pip if you haven’t already:

1

pip install numpy matplotlib