Exploring Cellular Automata In Python

Introduction

Cellular automata are a type of model that simulates the behavior of a system composed of individual cells based on a set of simple rules. These cells can have a finite number of states and are usually arranged in a regular grid. Each cell can interact with its neighboring cells, and the state of each cell evolves according to specific rules at each time step.

In this blog post, we will explore a simple example of cellular automata known as the "Game of Life," developed by British mathematician John Conway. We will then implement this model using Python and visualize the results.

Game of Life

The Game of Life is a zero-player game that simulates the evolution of a population of organisms based on simple rules. The game is played on an infinite 2D grid, where each cell can be in one of two states: alive or dead.

The rules for updating the state of each cell are as follows:

1. A living cell with 2 or 3 living neighbors will stay alive in the next generation.
2. A dead cell with exactly 3 living neighbors will come to life in the next generation.
3. All other cells will die or remain dead in the next generation.

These simple rules can produce a wide variety of complex patterns and behaviors, illustrating the potential of cellular automata for modeling complex systems.

Implementing the Game of Life in Python

To implement the Game of Life in Python, we will first create a function that initializes the grid with random states. We will then create a function that updates the grid based on the rules of the Game of Life, and finally, we will use the matplotlib library to visualize the results.

Here's a working implementation of the Game of Life in Python:

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

def initialize_grid(height, width):
    return np.random.choice([0, 1], size=(height, width), p=[0.5, 0.5])

def update_grid(grid):
    height, width = grid.shape
    new_grid = np.copy(grid)

    for i in range(height):
        for j in range(width):
            total = int((grid[i, (j-1)%width] + grid[i, (j+1)%width] +
                         grid[(i-1)%height, j] + grid[(i+1)%height, j] +
                         grid[(i-1)%height, (j-1)%width] + grid[(i-1)%height, (j+1)%width] +
                         grid[(i+1)%height, (j-1)%width] + grid[(i+1)%height, (j+1)%width]) / 1)
            if grid[i, j] == 1:
                if 2<= total <= 3:
                    new_grid[i, j]= 1
                else:
                    new_grid[i, j]=0
            else:
                if total == 3:
                    new_grid[i, j]=1

    return new_grid

def game_of_life(height=10, width=10):
    grid = initialize_grid(height, width)

    fig, ax = plt.subplots()
    im = ax.imshow(grid, cmap='gray')

    def animate(frame):
        nonlocal grid
        grid = update_grid(grid)
        im.set_array(grid)
        return [im]

    ani = animation.FuncAnimation(fig, animate, frames=200, interval=100, blit=True)
    plt.show()

game_of_life()

Conclusion

We have successfully implemented and visualized the Game of Life using Python. Cellular automata like this offer a simple yet powerful way to model complex systems and study emergent behaviors. By experimenting with different rules and initial conditions, you can explore a wide range of interesting patterns and applications.

There are many other types of cellular automata with different rules and dimensions, and some have important practical applications such as simulating fluid dynamics, traffic flow, and the spread of infectious diseases. If you are interested in learning more about cellular automata, consider exploring more advanced models and their applications in computer science, physics, and biology.