Autômatos Celulares: Explorando a Simplicidade Complexa

Os autômatos celulares são modelos computacionais simples e fascinantes que podem simular comportamentos complexos a partir de regras locais. Essa classe de sistemas é uma área importante de estudo em ciência da computação, matemática, física e outras disciplinas. Neste artigo, exploraremos os fundamentos dos autômatos celulares, seu funcionamento e implementação em Python.

Introdução aos Autômatos Celulares

Um autômato celular é um modelo discreto que consiste em uma grade de células, cada uma com um estado que pode mudar ao longo do tempo. A evolução do sistema é governada por regras locais simples, onde o estado de uma célula em uma etapa de tempo depende apenas dos estados das células vizinhas na etapa anterior.

A estrutura básica de um autômato celular é uma grade unidimensional, bidimensional ou tridimensional, mas também podem ser explorados arranjos mais complexos. Os autômatos celulares são uma ferramenta poderosa para explorar fenômenos emergentes e padrões complexos a partir de interações locais.

O Modelo Matemático

Considere um autômato celular unidimensional com uma grade de células, onde cada célula pode assumir um estado em um conjunto finito de estados possíveis. Denotemos o estado de uma célula na posição i e tempo t por C(i, t).

A evolução do autômato celular é governada por uma regra local, que descreve como o estado de uma célula muda com base nos estados de suas células vizinhas. Uma regra pode ser representada por uma tabela ou uma fórmula matemática.

Uma notação comum é usar uma notação de vizinhança para descrever as células vizinhas de uma célula central. Por exemplo, para um autômato celular unidimensional com vizinhança de von Neumann de raio 1, a regra pode ser escrita como:

$$ C(i, t+1) = f(C(i-1, t), C(i, t), C(i+1, t)) $$

Onde f é a função que define a regra local. Existem muitas possibilidades para a função f, e cada escolha pode levar a comportamentos completamente diferentes do autômato.

Implementação em Python

Vamos implementar um autômato celular unidimensional em Python usando a biblioteca matplotlib para visualização. Nesta implementação, usaremos uma regra binária, onde cada célula pode estar em um dos dois estados: 0 ou 1.

import numpy as np
import matplotlib.pyplot as plt

def apply_rule(rule_number, neighborhood):
    """Aplica a regra do autômato celular para uma vizinhança."""
    return (rule_number >> neighborhood) & 1

def cellular_automaton(rule_number, size, steps):
    """Simula o autômato celular com a regra dada."""
    initial_state = np.zeros(size, dtype=int)
    initial_state[size // 2] = 1  # Estado inicial com uma célula ativada no meio

    states = [initial_state]

    for _ in range(steps):
        current_state = states[-1]
        new_state = np.zeros(size, dtype=int)

        for i in range(size):
            neighborhood = (current_state[(i-1) % size], current_state[i], current_state[(i+1) % size])
            new_state[i] = apply_rule(rule_number, neighborhood)

        states.append(new_state)

    return states

def plot_cellular_automaton(states):
    """Visualiza o autômato celular ao longo do tempo."""
    plt.figure(figsize=(10, 6))
    plt.imshow(states, cmap='Greys', origin='lower', aspect='auto')
    plt.xlabel('Tempo')
    plt.ylabel('Posição')
    plt.title('Autômato Celular Unidimensional')
    plt.show()

if __name__ == '__main__':
    rule_number = 110  # Exemplo de uma regra interessante
    size = 100         # Tamanho da grade
    steps = 50         # Número de etapas de tempo

    states = cellular_automaton(rule_number, size, steps)
    plot_cellular_automaton(states)

Neste exemplo, usamos a regra de número 110, que é conhecida por gerar padrões complexos e interessantes.

Gerando um GIF com as diversas iterações de um sistema de autômatos celulares

Logo abaixo, implementamos uma função em python para gerar um gif das diversas iterações de um sistema de autômatos celulares, considerando como parâmetros iniciais: a regra utilizada e uma matriz 10x10, onde: 1 representa uma célula viva e 0 uma célula morta. Além disso, inicializamos com valores aleatórios.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from matplotlib.colors import ListedColormap
from PIL import Image

def apply_rule(rule_number, neighborhood):
    """Aplica a regra do autômato celular para uma vizinhança."""
    neighborhood_value = 0
    for i, cell in enumerate(neighborhood):
        neighborhood_value |= cell << i
    return (rule_number >> neighborhood_value) & 1

def cellular_automaton(rule_number, size, steps):
    """Simula o autômato celular com a regra dada."""
    initial_state = np.random.randint(2, size=(size, size), dtype=int)

    states = [initial_state]

    for _ in range(steps):
        current_state = states[-1]
        new_state = np.zeros_like(current_state)

        for i in range(size):
            for j in range(size):
                neighborhood = (
                    current_state[i-1, j-1], current_state[i-1, j], current_state[i-1, (j+1) % size],
                    current_state[i, j-1], current_state[i, j], current_state[i, (j+1) % size],
                    current_state[(i+1) % size, j-1], current_state[(i+1) % size, j], current_state[(i+1) % size, (j+1) % size]
                )
                new_state[i, j] = apply_rule(rule_number, neighborhood)

        states.append(new_state)

    return states

def plot_cellular_automaton(states, rule_number):
    """Visualiza o autômato celular em um GIF."""
    cmap = ListedColormap(['white', 'black'])
    fig, ax = plt.subplots()
    ax.axis('off')

    def update(frame):
        ax.clear()
        ax.imshow(states[frame], cmap=cmap, origin='lower', aspect='auto')
        ax.set_title(f'Iteração {frame} - Regra {rule_number}')

    ani = FuncAnimation(fig, update, frames=len(states), interval=300)
    ani.save(f'cellular_automaton_rule_{rule_number}.gif', writer='pillow', fps=2)

if __name__ == '__main__':
    rule_number = 110  # Exemplo de uma regra interessante
    size = 10          # Tamanho da grade (matriz 10x10)
    steps = 20         # Número de iterações

    states = cellular_automaton(rule_number, size, steps)
    plot_cellular_automaton(states, rule_number)

A função cellular_automaton simula o autômato celular para o número especificado de iterações. A função plot_cellular_automaton gera a animação das iterações e salva o GIF com base na regra fornecida.

Ao executar esse código, será gerado um GIF que mostra as diversas iterações do autômato celular com a regra especificada. Cada quadro representa uma iteração do sistema. Você pode ajustar os parâmetros rule_number, size e steps para experimentar diferentes regras e tamanhos da grade.

Conclusão

Os autômatos celulares são modelos matemáticos intrigantes que demonstram como comportamentos complexos podem emergir de regras locais simples. Eles têm aplicações em várias áreas, incluindo simulações computacionais, criptografia, modelagem de sistemas biológicos e muito mais.

Explorar autômatos celulares nos ajuda a entender melhor a natureza da complexidade e como ela pode surgir a partir de elementos simples. Com a implementação em Python fornecida, você pode se aventurar em diferentes regras e tamanhos de grade para descobrir padrões fascinantes e inesperados. Divirta-se explorando este mundo de simplicidade complexa!