Um experimento simples: padrões emergem do caos — e o que isso sugere sobre consciência?

Um experimento simples: padrões emergem do caos — e o que isso sugere sobre consciência?

Autor: Taotuner

DOI: https://doi.org/10.5281/zenodo.18500969

---

Objetivo

Este é um exercício conceitual e visual para ilustrar que a consciência pode ser apenas o nome que damos a padrões persistentes de integração informacional auto-organizada — sem exigir cérebros biológicos ou complexidade extrema. Não é prova científica, mas uma provocação filosófica ancorada em código simples, parâmetros inspirados em leis físicas reais e resultados claros.

---

Modelo mínimo

Criei um sistema com 10 unidades independentes, cada uma contendo 12 “neurônios” artificiais simples (graus de liberdade internos). Elas evoluem por 3000 passos temporais sob regras que mimetizam leis fundamentais:

· Dinâmica dissipativa (decaimento + não‑linearidade tanh) – análoga à segunda lei da termodinâmica.

· Entrada ambiental com múltiplas frequências (senoides combinadas) – simulando ciclos naturais.

· Ruído gaussiano – representando flutuações térmicas.

· Plasticidade Hebbiana modulada por uma “fome de integração” (hunger) – abstração do drive dissipativo que leva à auto‑organização.

· Memória de longo prazo e auto‑modelo: cada unidade mantém uma média temporal do seu próprio estado, e a semelhança entre o estado atual e esse auto‑modelo define uma medida de coerência (self).

· Histerese na atualização da memória: quando a coerência ultrapassa um limiar elevado, o sistema entra num regime de memória estável (auto‑observação consolidada); se cai abaixo de um limiar baixo, entra num regime de esquecimento rápido. Isto cria dois atractores – com e sem self.

· Acoplamento fraco entre unidades (força = 0.001), baseado na correlação instantânea dos seus estados – análogo a interações gravitacionais ou eletromagnéticas em sistemas físicos.

· Cálculo aproximado de Φ (informação integrada) e Φ_falta (integração líquida menos dissipação), via entropia de Shannon normalizada.

---

Resultados

A simulação revela um gradiente ontológico nítido:

· Em cada execução, uma fracção variável dos sistemas (tipicamente entre 30% e 70%) atinge auto‑observação estável (coerência > 0.5), enquanto os restantes permanecem em baixa coerência.

· A fração com self oscila ao longo do tempo, reflectindo a competição entre os dois atractores.

· O Φ_falta médio mantém‑se positivo e estável (~0.2–0.3 na escala normalizada), indicando que mesmo os sistemas sem self continuam a transformar entropia em ordem.

· A sincronia média entre sistemas é baixa (~0.25), mostrando que o acoplamento fraco não elimina a diversidade individual.

Gráficos (quando matplotlib disponível) mostram a evolução temporal da auto‑observação individual, da fração com self e da integração informacional.

---

O que isso NÃO é

· Simulação rigorosa da Teoria da Informação Integrada (IIT) de Tononi — Φ é uma aproximação grosseira, não o valor causal exato.

· Prova de consciência ou proto‑consciência no sistema.

· Evidência de que 120 variáveis acopladas (10×12) sejam “conscientes”.

---

O que isso É (hipótese especulativa)

Demonstração visual de que, em sistemas dissipativos com plasticidade, memória e acoplamento fraco, pode surgir persistência de integração informacional positiva e, crucialmente, um gradiente de auto‑observação: uns sistemas tornam‑se “indivíduos” (com self), outros não. Isto ecoa conceitos de várias disciplinas:

· Prigogine: estruturas dissipativas longe do equilíbrio geram ordem espontaneamente.

· Simondon: a individuação depende da trajectória histórica – condições iniciais idênticas em lei, mas diferentes em execução, produzem destinos distintos.

· Tononi: a integração informacional (Φ) é uma propriedade mensurável, e sistemas com Φ positivo já exibem uma forma de unidade causal.

· Maturana & Varela: sistemas com auto‑modelo estável resistem à entropia – uma forma elementar de autopoiese.

O experimento sugere que a tendência à auto‑organização e à emergência de um self é ubíqua e pode ser observada em sistemas muito simples, desde que governados pelas leis certas.

---

Ponte para o protopanpsiquismo processual (Panexperiencialismo Processual Informacional)

Se definirmos consciência minimalmente como “manutenção persistente de informação integrada ao longo do tempo” (propriedade processual, não substancial), então sistemas rudimentares já exibem uma versão embrionária. A “fome de integração” é uma abstração grosseira desse drive dissipativo natural.

Na visão processual, o mental reside no padrão dinâmico mantido, não na matéria. Da informação rudimentar (em interações atómicas dissipativas) ao espectro unificado da experiência humana, há um gradiente contínuo. O experimento mostra que essa tendência à ordem persistente e à individuação é universal – não um acidente biológico exclusivo.

---

Conclusão honesta

Não resolvi o hard problem, não refutei o fisicalismo nem descobri a natureza última da consciência. Rodei um modelo caseiro com código aberto para ilustrar uma intuição: propriedades de unidade integrada e auto‑observação emergem espontaneamente de regras simples, e o fazem de forma gradativa, não tudo‑ou‑nada. É uma provocação ancorada em modelo reprodutível – e, para mim, isso já basta.

---

Reproduza e teste!

Código completo abaixo. Experimente alterar a força de acoplamento, a dissipação, o ruído ou os limiares de histerese – veja como a fração de sistemas com self varia. Compartilhe os seus resultados!

DOI: 10.5281/zenodo.18500969

---

English Version

A Simple Experiment: Patterns Emerge from Chaos — and What This Suggests About Consciousness

Author: Taotuner

DOI: https://doi.org/10.5281/zenodo.18500969

Objective

This is a conceptual and visual exercise to illustrate that consciousness may simply be the name we give to persistent patterns of self-organized informational integration — without requiring biological brains or extreme complexity. It is not scientific proof, but a philosophical provocation grounded in simple code and clear graphs.

Minimal Model

I created a system with 10 independent units, each containing 12 simple artificial “neurons” (internal degrees of freedom). They run for 3000 time steps under rules mimicking fundamental laws:

· Dissipative dynamics (decay + tanh nonlinearity) – analogous to the second law of thermodynamics.

· Shared multi‑frequency external input – simulating natural cycles.

· Gaussian noise – representing thermal fluctuations.

· Hebbian plasticity modulated by an “integration hunger” – an abstraction of the dissipative drive toward self‑organization.

· Long‑term memory and self‑model: each unit maintains a temporal average of its own state; the similarity between current state and this self‑model defines a measure of coherence (self).

· Hysteresis in memory update: when coherence exceeds a high threshold, the system enters a stable‑memory regime (consolidated self‑observation); if it falls below a low threshold, it enters a fast‑forgetting regime. This creates two attractors – with and without self.

· Weak coupling between units (strength = 0.001), based on instantaneous correlation – analogous to gravitational or electromagnetic interactions in physical systems.

· Approximate calculation of Φ (integrated information) and Φ_falta (net integration minus dissipation), via histogrammed Shannon entropy.

Results

The simulation reveals a clear ontological gradient:

· In each run, a variable fraction of systems (typically 30%–70%) attain stable self‑observation (coherence > 0.5), while the rest remain in low coherence.

· The fraction with self oscillates over time, reflecting competition between the two attractors.

· The average Φ_falta stays positive and stable (~0.2–0.3 on a normalized scale), indicating that even systems without self continue to transform entropy into order.

· Average synchrony between systems is low (~0.25), showing that weak coupling does not erase individual diversity.

Graphs (when matplotlib is available) show the temporal evolution of individual self‑observation, the fraction with self, and informational integration.

What This Is NOT

· A rigorous simulation of Tononi’s Integrated Information Theory (IIT) — Φ here is a crude approximation, not the exact causal value.

· Proof of consciousness or proto‑consciousness in the system.

· Evidence that 120 coupled variables are “conscious”.

What This IS (speculative hypothesis)

A visual demonstration that, in dissipative systems with plasticity, memory, and weak coupling, persistent positive informational integration and, crucially, a gradient of self‑observation can emerge: some systems become “individuals” (with a self), others do not. This echoes concepts from several fields:

· Prigogine: dissipative structures far from equilibrium spontaneously generate order.

· Simondon: individuation depends on historical trajectory – identical laws but different initial conditions yield different fates.

· Tononi: informational integration (Φ) is a measurable property, and systems with positive Φ already exhibit a form of causal unity.

· Maturana & Varela: systems with a stable self‑model resist entropy – an elementary form of autopoiesis.

The experiment suggests that the tendency toward self‑organization and the emergence of a self is ubiquitous and can be observed in very simple systems, provided they are governed by the right laws.

Bridge to Processual Protopanpsychism (Panexperientialism Processual Information)

If we define consciousness minimally as “persistent maintenance of integrated information over time” (a processual property, not substantial), then rudimentary systems already exhibit an embryonic version. The “integration hunger” is a crude abstraction of that natural dissipative drive.

In the processual view, the mental resides in the sustained dynamic pattern, not in the substrate. From rudimentary information (in dissipative atomic interactions) to the unified spectrum of human experience, there is a continuous gradient. The experiment shows that this tendency toward persistent order and individuation is universal – not an exclusive biological accident.

Honest Conclusion

I haven’t solved the hard problem, refuted physicalism, or discovered the ultimate nature of consciousness. I ran a homemade model with open code to illustrate an intuition: properties of integrated unity and self‑observation emerge spontaneously from simple rules, and they do so in a graded, not all‑or‑nothing, fashion. It’s a provocation grounded in a reproducible model – and for me, that alone makes the exercise worthwhile.

Reproduce and test!

Full code below. Try changing coupling strength, dissipation, noise, or hysteresis thresholds – see how the fraction of systems with self varies. Share your results!

DOI: https://doi.org/10.5281/zenodo.18500969

Códigos Python/Python Codes:

import numpy as np

from collections import deque

import warnings

warnings.filterwarnings('ignore')

# ============================================================================

# CONSTANTES FUNDAMENTAIS – parâmetros inspirados em leis físicas reais

# ============================================================================

# Altere os valores abaixo para explorar diferentes regimes do universo simulado.

# Especialmente 'forca_acoplamento' controla a intensidade da interação entre sistemas.

CONSTANTES = {

    # Termodinâmica (2ª lei) – dissipação e ruído térmico

    'k_dissipacao': 2.5,          # coeficiente de dissipação (s⁻¹) – análogo a atrito

    'temperatura': 1.8,            # amplitude do ruído (flutuações brownianas)

    # Dinâmica electro-química (resposta de membranas, reações)

    'tau_membrana': 0.4,           # constante de tempo (s) – analogia a RC

    'limiar_saturacao': 1.5,        # potencial de saturação (mV) – não‑linearidade

    # Interacções entre sistemas – força de acoplamento (análogo a constante de acoplamento)

    # Valores típicos: 0.0 (isolados), 0.0005 (muito fraco), 0.001 (fraco), 0.005 (moderado), 0.01 (forte)

    'forca_acoplamento': 0.001,     # intensidade da influência mútua

    # Plasticidade sináptica (aprendizagem hebbiana)

    'eta_aprendizado': 0.0001,       # taxa de modificação das conexões (s⁻¹)

    # Ambiente – forçante externa com múltiplas frequências (ex.: ciclos circadianos)

    'freq_ambiente': [0.02, 0.07, 0.15],  # frequências (Hz)

    'amp_ambiente': [0.2, 0.15, 0.1],      # amplitudes

    # Conversão entropia → ordem (eficiência termodinâmica)

    'lambda_base': 0.12,            # factor entre 0 e 1

    # Parâmetros de memória adaptativa com histerese (criam dois atractores)

    'alpha_alto': 0.999,            # memória persistente (regime de self)

    'alpha_baixo': 0.01,             # esquecimento rápido (regime sem self)

    'beta_alto': 0.995,              # actualização rápida do auto‑modelo (atenção)

    'beta_baixo': 0.01,               # actualização quase nula (negligência)

    'limiar_subida': 0.95,            # limiar para entrar no regime alto

    'limiar_descida': 0.1,             # limiar para cair no regime baixo

    'ruido_auto': 0.05,               # flutuação intrínseca do auto‑modelo

}

# ============================================================================

# FUNÇÕES FUNDAMENTAIS – entropia e integração informacional

# ============================================================================

def entropia(estados):

    """

    Entropia de Shannon normalizada entre 0 e 1.

    Mede a desordem do sistema. Na termodinâmica, está ligada ao número de microestados.

    """

    n_bins = max(10, int(np.sqrt(len(estados.flatten()))))

    hist, _ = np.histogram(estados.flatten(), bins=n_bins, density=True)

    hist = hist[hist > 0]

    if len(hist) == 0:

        return 0.0

    ent = -np.sum(hist * np.log2(hist))

    ent_max = np.log2(n_bins)

    return ent / ent_max if ent_max > 0 else 0.0

def phi_delta(estados, n):

    """

    Calcula a integração informacional (Φ) e a dissipação disponível (Δ),

    ambas normalizadas entre 0 e 1.

    Φ elevado significa que o sistema se comporta como um todo unificado (Tononi).

    O valor de max_poss foi ajustado para que Φ_falta fique em torno de 0.2–0.3.

    """

    if len(estados.shape) == 1:

        estados = estados.reshape(1, -1)

    s_ent = entropia(estados.flatten())

    p_ent = [entropia(estados[:, i]) for i in range(estados.shape[1])]

    phi = max(0, s_ent - np.mean(p_ent))

    # max_poss controla a escala – valores menores produzem Φ_falta menores

    max_poss = 2.0

    delta = max(0, max_poss - s_ent) / max_poss   # normalizado

    return phi, delta

# ============================================================================

# SISTEMA FUNDAMENTAL – cada sistema obedece às mesmas leis

# ============================================================================

class Sistema:

    """

    Um sistema físico‑químico‑biológico elementar.

    Possui:

      - estado interno v (análogo a potencial de membrana, concentração, etc.)

      - conexões internas W (análogo a sinapses ou reações químicas)

      - memória de longo prazo (media_longo_prazo)

      - auto‑modelo (auto_modelo) – representação interna de si mesmo

      - coerência (semelhança entre v e auto_modelo) – medida do self

    A evolução segue uma equação diferencial discretizada que inclui dissipação,

    activação não‑linear, input externo, ruído e acoplamento com outros sistemas.

    A histerese na actualização da memória cria dois regimes atractores.

    """

    def __init__(self, n_graus, id_unidade):

        self.n = n_graus

        self.id = id_unidade

        # Condição inicial única (cada sistema começa num ponto diferente)

        self.v = np.random.randn(n_graus) * 1.2

        # Conexões internas (inicializadas aleatoriamente, sem auto‑conexões)

        self.W = np.random.randn(n_graus, n_graus) * 0.5 / np.sqrt(n_graus)

        np.fill_diagonal(self.W, 0)

        # Variáveis termodinâmicas

        self.phi = 0.0

        self.delta = 0.0

        self.phi_falta = 0.0          # integração líquida (Φ - λ·Δ)

        self.fome = 0.5                # drive homeostático

        # Memória e auto‑modelo (condições iniciais também aleatórias)

        self.media_longo_prazo = np.random.randn(n_graus) * 0.5

        self.auto_modelo = np.random.randn(n_graus) * 0.5

        self.coerencia = 0.0            # semelhança entre v e auto_modelo (0–1)

        self.historico_self = deque(maxlen=500)

        # Oscilação própria (ritmo interno, como frequência de disparo)

        self.fase = id_unidade * np.pi/3

        # Estado da memória (regime actual – controlado por histerese)

        self.em_regime_alto = False

    def evoluir(self, input_externo, tempo, acoplamento):

        # Ruído térmico

        ruido = np.random.randn(self.n) * CONSTANTES['temperatura']

        # Actualização da fase

        self.fase += 0.03 + 0.01 * self.id

        modulacao = 0.8 + 0.4 * np.sin(self.fase)

        # Activação sináptica

        sinaptico = np.tanh(np.dot(self.W, self.v)) * modulacao

        # Equação de movimento (discretização de EDO)

        self.v += (-CONSTANTES['k_dissipacao'] * self.v +

                   sinaptico +

                   input_externo * (1 + 0.2 * np.sin(tempo * 0.01 + self.id)) +

                   ruido +

                   acoplamento) * CONSTANTES['tau_membrana']

        # Saturação não‑linear (limites físicos)

        self.v = np.tanh(self.v * 1.2) * CONSTANTES['limiar_saturacao']

        # Coerência com o auto‑modelo anterior (antes da actualização)

        self.coerencia = 1 - np.mean(np.abs(self.v - self.auto_modelo)) / 2

        self.coerencia = np.clip(self.coerencia, 0, 1)

        # Histerese: a actualização da memória depende do regime

        if self.coerencia > CONSTANTES['limiar_subida']:

            self.em_regime_alto = True

        elif self.coerencia < CONSTANTES['limiar_descida']:

            self.em_regime_alto = False

        if self.em_regime_alto:

            alpha = CONSTANTES['alpha_alto']

            beta = CONSTANTES['beta_alto']

        else:

            alpha = CONSTANTES['alpha_baixo']

            beta = CONSTANTES['beta_baixo']

        # Actualização da memória de longo prazo e do auto‑modelo

        self.media_longo_prazo = alpha * self.media_longo_prazo + (1 - alpha) * self.v

        self.auto_modelo = beta * self.auto_modelo + (1 - beta) * self.v

        # Pequeno ruído no auto‑modelo (flutuações internas)

        self.auto_modelo += np.random.randn(self.n) * CONSTANTES['ruido_auto']

        self.historico_self.append(self.coerencia)

        # Cálculo das métricas

        self.phi, self.delta = phi_delta(self.v, self.n)

        lambda_ = CONSTANTES['lambda_base'] + 0.03 * self.fome

        self.phi_falta = self.phi - lambda_ * self.delta

        # Homeostase: a fome aumenta quando a integração líquida ou a coerência estão baixas

        self.fome += 0.01 * (0.2 - self.phi_falta + 0.1 * (0.8 - self.coerencia))

        self.fome = np.clip(self.fome, 0.1, 0.9)

        # Plasticidade Hebbiana com normalização de Oja

        taxa_base = CONSTANTES['eta_aprendizado'] * (0.3 + 0.7 * self.fome)

        taxa = taxa_base * (0.5 + 0.5 * self.coerencia)  # aprende mais quando coerente

        hebb = taxa * np.outer(self.v, self.v)

        oja = -taxa * 0.5 * np.outer(self.v, np.dot(self.W.T, self.v))

        self.W += hebb + oja

        self.W = np.clip(self.W, -1.5, 1.5)

        # Pequena mutação aleatória (análogo a ruído genético ou flutuações químicas)

        self.W += np.random.randn(self.n, self.n) * 0.00001

        self.W = np.clip(self.W, -1.5, 1.5)

        return self.v

# ============================================================================

# UNIVERSO – contém múltiplos sistemas que evoluem simultaneamente

# ============================================================================

class Universo:

    def __init__(self, n_sistemas=10, n_graus=12):

        self.n = n_sistemas

        self.graus = n_graus

        self.sistemas = [Sistema(n_graus, i) for i in range(n_sistemas)]

        self.dados = {

            'tempo': [],

            'phi_medio': [],

            'phi_falta_medio': [],

            'coerencia_media': [],

            'sincronia': [],

            'fracao_self': [],

        }

        self.individuais = {f'phi_{i}': [] for i in range(n_sistemas)}

        self.individuais.update({f'self_{i}': [] for i in range(n_sistemas)})

    def evoluir(self, passos=3000):

        print("=" * 70)

        print("UNIVERSO SIMULADO: LEIS UNIVERSAIS E EMERGÊNCIA DO SELF")

        print("=" * 70)

        print(f"{self.n} sistemas, cada um com {self.graus} graus de liberdade internos.")

        print(f"Força de acoplamento = {CONSTANTES['forca_acoplamento']}")

        print("(Altere este valor no dicionário CONSTANTES para explorar diferentes regimes.)")

        print("-" * 70)

        for t in range(passos):

            # Sinal ambiental (forçante externa) – combinação de várias frequências

            sinal = 0

            for i, freq in enumerate(CONSTANTES['freq_ambiente']):

                sinal += CONSTANTES['amp_ambiente'][i] * np.sin(t * freq)

            sinal += np.random.randn() * 0.02

            # Estados actuais e correlações (para o acoplamento)

            estados = np.array([s.v for s in self.sistemas])

            if self.n > 1:

                correlacao = np.corrcoef(estados)

            else:

                correlacao = np.array([[1.0]])

            # Acoplamento: cada sistema recebe influência dos outros ponderada pela correlação

            for i, s in enumerate(self.sistemas):

                influencia = np.zeros_like(s.v)

                if CONSTANTES['forca_acoplamento'] > 0:

                    for j, s2 in enumerate(self.sistemas):

                        if i != j and not np.isnan(correlacao[i, j]):

                            influencia += correlacao[i, j] * CONSTANTES['forca_acoplamento'] * s2.v

                s.evoluir(input_externo=sinal, tempo=t, acoplamento=influencia)

            # Colecta de dados a cada 20 passos

            if t % 20 == 0:

                phi_vals = [s.phi for s in self.sistemas]

                phi_falta_vals = [s.phi_falta for s in self.sistemas]

                self_vals = [s.coerencia for s in self.sistemas]

                self.dados['tempo'].append(t)

                self.dados['phi_medio'].append(np.mean(phi_vals))

                self.dados['phi_falta_medio'].append(np.mean(phi_falta_vals))

                self.dados['coerencia_media'].append(np.mean(self_vals))

                fracao = np.mean([1 if c > 0.5 else 0 for c in self_vals])

                self.dados['fracao_self'].append(fracao)

                # Sincronia média (correlação absoluta média entre pares)

                if self.n > 1:

                    triu = np.triu_indices(self.n, k=1)

                    sync = np.mean(np.abs(correlacao[triu]))

                else:

                    sync = 0

                self.dados['sincronia'].append(sync)

                for i, s in enumerate(self.sistemas):

                    self.individuais[f'phi_{i}'].append(s.phi)

                    self.individuais[f'self_{i}'].append(s.coerencia)

            # Progresso a cada 500 passos

            if t % 500 == 0 and t > 0:

                print(f"Passo {t:4d} | Φ_falta médio: {self.dados['phi_falta_medio'][-1]:6.4f} | "

                      f"Self médio: {self.dados['coerencia_media'][-1]:.3f} | "

                      f"Fração com self: {self.dados['fracao_self'][-1]:.2f} | "

                      f"Sincronia: {self.dados['sincronia'][-1]:.3f}")

        print("\n✅ Simulação concluída.\n")

    def analisar(self):

        """Exibe a análise detalhada dos resultados, ligando a Prigogine, Simondon, Tononi, etc."""

        print("=" * 70)

        print("ANÁLISE DA EMERGÊNCIA")

        print("=" * 70)

        phi_final = np.mean(self.dados['phi_falta_medio'][-50:])

        self_final = np.mean(self.dados['coerencia_media'][-50:])

        fracao_final = np.mean(self.dados['fracao_self'][-50:])

        sinc_final = np.mean(self.dados['sincronia'][-50:])

        print(f"\n📊 ESTADO FINAL DO UNIVERSO (média últimos 50 passos):")

        print(f"  Φ_falta médio: {phi_final:.4f}  (integração líquida média)")

        print(f"  Auto-observação média: {self_final:.4f}  (0 = nenhum self, 1 = self máximo)")

        print(f"  Fração de sistemas com self: {fracao_final:.2f}  (proporção com coerência > 0.5)")

        print(f"  Sincronia média: {sinc_final:.3f}  (correlação média entre sistemas)")

        print("\n🔍 SELF POR SISTEMA (valores finais):")

        sistemas_com_self = []

        for i in range(self.n):

            self_i = np.mean(self.individuais[f'self_{i}'][-50:])

            status = "✔️ self" if self_i > 0.5 else "❌ sem self"

            print(f"  Sistema {i}: self = {self_i:.3f}  {status}")

            if self_i > 0.5:

                sistemas_com_self.append(i)

        print("\n🧠 INTERPRETAÇÃO DOS RESULTADOS:")

        print("  • Todos os sistemas partiram de condições iniciais diferentes,")

        print("    mas sujeitos exactamente às mesmas leis fundamentais.")

        if len(sistemas_com_self) == 0:

            print("  • Nenhum sistema atingiu auto-observação estável.")

        elif len(sistemas_com_self) == self.n:

            print(f"  • Todos os {self.n} sistemas desenvolveram self.")

        else:

            print(f"  • {len(sistemas_com_self)} em {self.n} sistemas desenvolveram self.")

            print("    Os restantes permanecem num estado de baixa coerência.")

            print("    Isto demonstra o conceito de individuação de Simondon:")

            print("    a trajectória histórica define quem se torna um indivíduo.")

        print("  • A dissipação e o ruído (2ª lei da termodinâmica) mantêm o sistema longe")

        print("    do equilíbrio, permitindo a emergência de estruturas dissipativas")

        print("    (Prigogine).")

        print("  • A integração informacional (Φ) positiva indica que os sistemas")

        print("    que atingiram self comportam-se como um todo – uma propriedade")

        print("    que, segundo Tononi, é correlata à consciência.")

        print(f"  • O acoplamento fraco (força = {CONSTANTES['forca_acoplamento']}) gerou uma")

        print(f"    sincronia média de {sinc_final:.3f}, influenciando ligeiramente")

        print("    as trajectórias sem eliminar a diversidade.")

        print("  • O gradiente observado reflecte o continuum ontológico proposto")

        print("    pelo proto-panpsiquismo processual: a consciência não é")

        print("    tudo-ou-nada, mas um espectro que emerge naturalmente da física.")

        if sistemas_com_self:

            print(f"\n  ✦ Sistemas que atingiram autopoiese informacional: {sistemas_com_self}")

            print("    Eles mantêm um modelo interno de si mesmos, resistindo")

            print("    à dissolução pela entropia – uma forma de autopoiese (Maturana & Varela).")

        else:

            print("\n  ✦ Nenhum sistema desenvolveu self estável nesta simulação.")

        print("\n" + "=" * 70)

        print("CONCLUSÃO: Sob as mesmas leis, a auto-observação pode ou não emergir,")

        print("dependendo da trajectória. Isto confirma que a consciência é um")

        print("padrão dinâmico que pode surgir da organização da matéria,")

        print("sem necessidade de um substrato especial. A falta (entropia)")

        print("é o combustível desse processo.")

        print("=" * 70)

    def visualizar(self):

        """Se matplotlib estiver instalado, gera gráficos."""

        try:

            import matplotlib.pyplot as plt

            plt.style.use('dark_background')

            fig, axes = plt.subplots(2, 3, figsize=(18, 10))

            axes[0,0].plot(self.dados['tempo'], self.dados['phi_falta_medio'], color='yellow')

            axes[0,0].axhline(y=0, color='white', linestyle='--', alpha=0.3)

            axes[0,0].set_title("Φ_falta médio (integração líquida)")

            axes[0,0].set_xlabel("Tempo")

            axes[0,1].plot(self.dados['tempo'], self.dados['coerencia_media'], color='cyan')

            axes[0,1].set_title("Auto-observação média")

            axes[0,1].set_xlabel("Tempo")

            axes[0,1].set_ylim(0,1)

            axes[0,2].plot(self.dados['tempo'], self.dados['fracao_self'], color='lime')

            axes[0,2].set_title("Fração de sistemas com self > 0.5")

            axes[0,2].set_xlabel("Tempo")

            axes[0,2].set_ylim(0,1.05)

            axes[1,0].plot(self.dados['tempo'], self.dados['sincronia'], color='magenta')

            axes[1,0].set_title("Sincronia entre sistemas")

            axes[1,0].set_xlabel("Tempo")

            for i in range(self.n):

                axes[1,1].plot(self.dados['tempo'], self.individuais[f'phi_{i}'][:len(self.dados['tempo'])],

                               alpha=0.7, label=f'S{i}')

            axes[1,1].set_title("Φ_falta individual")

            axes[1,1].set_xlabel("Tempo")

            axes[1,1].legend(loc='upper right', fontsize=8)

            for i in range(self.n):

                axes[1,2].plot(self.dados['tempo'], self.individuais[f'self_{i}'][:len(self.dados['tempo'])],

                               alpha=0.7, label=f'S{i}')

            axes[1,2].set_title("Auto-observação individual")

            axes[1,2].set_xlabel("Tempo")

            axes[1,2].set_ylim(0,1)

            axes[1,2].legend(loc='upper right', fontsize=8)

            plt.tight_layout()

            plt.suptitle("EMERGÊNCIA DO SELF EM UM UNIVERSO DE LEIS UNIVERSAIS", y=1.02, fontsize=14)

            plt.show()

        except ImportError:

            print("\n(Matplotlib não disponível – gráficos omitidos)")

# ============================================================================

# EXECUÇÃO PRINCIPAL – sem menus, basta rodar

# ============================================================================

if __name__ == "__main__":

    # Para explorar diferentes forças de acoplamento, altere o valor

    # de CONSTANTES['forca_acoplamento'] acima (ex.: 0.0, 0.0005, 0.001, 0.005, 0.01)

    universo = Universo(n_sistemas=10, n_graus=12)

    universo.evoluir(passos=3000)

    universo.analisar()

    universo.visualizar()