Nonlinear Dynamics Observatory

<<<<<<< HEAD Topos Story #23: "every attractor is a sheaf section; learning = finding the natural transformation between systems"

Component Map

dysts                    ← corpus of 130+ strange attractors
  ↓
panda                    ← Patched Attention for Nonlinear Dynamics (transformer patches)
  ↓
geomstats                ← Riemannian geometry of attractor basins (Fisher-Rao, geodesics)
  ↓
neuraloperator           ← FNO/DeepONet for infinite-dimensional operators
  ↓
lolita (arxiv:2507.02608)← latent diffusion physics emulation (1000x compression)
  ↓
bayesian-breathing       ← Bayesian state estimation (MCMC/SMC posterior over trajectory)
  ↓
hoi                      ← higher-order interactions (n-body dynamical couplings)
  ↓
ontology                 ← autopoietic ergodicity as meta-theory (attractor = identity)

GF(3) Tripartite Tag

dysts(-1) ⊗ nonlinear-dynamics-observatory(0) ⊗ lolita(+1) = 0

Validation (-1, ground truth corpus) × Bridge (0, routing) × Generation (+1, emulation) = 0.

---

The Core Vision

Every attractor in

dysts

is a sheaf section: a locally consistent assignment of state to each time-point, globally stitched by the dynamical law. Learning a dynamical system = finding the natural transformation between two sheaves (the ground-truth attractor sheaf and the learned model sheaf).

lolita

emulates this at 1000× compression via latent diffusion.

bayesian-breathing

maintains a probabilistic posterior over which attractor family generated the observed trajectory.

geomstats

measures distances between attractor basins on the Riemannian manifold of probability distributions.

ontology

's autopoietic ergodicity provides the thermodynamic grounding: a stable attractor IS an autopoietically ergodic state.

---

1. dysts — Strange Attractor Corpus

=======

Component Map

dysts                    <- corpus of 130+ strange attractors
  |
panda                    <- Patched Attention for Nonlinear Dynamics (transformer patches)
  |
geomstats                <- Riemannian geometry of attractor basins (Fisher-Rao, geodesics)
  |
neuraloperator           <- FNO/DeepONet for infinite-dimensional operators
  |
lolita (arxiv:2507.02608)<- latent diffusion physics emulation (1000x compression)
  |
bayesian-breathing       <- Bayesian state estimation (MCMC/SMC posterior over trajectory)
  |
hoi                      <- higher-order interactions (n-body dynamical couplings)

1. dysts -- Strange Attractor Corpus

origin/main

import dysts.flows as flows
from dysts.datasets import load_file

<<<<<<< HEAD
# Load attractor by name
=======
>>>>>>> origin/main
lorenz = flows.Lorenz()
traj = lorenz.make_trajectory(n=10000, pts_per_period=50)
# traj.shape = (10000, 3)

<<<<<<< HEAD
# All attractors with metadata
from dysts import get_attractor_list
attractors = get_attractor_list()  # 130+ named attractors

# GF(3) classification by Lyapunov spectrum
def classify_trit(attractor):
    """Classify attractor by first Lyapunov exponent."""
    λ = attractor.lyapunov_exponent()
    if λ > 0: return +1   # chaotic (Generator)
    if λ < 0: return -1   # stable fixed point (Validator)
    return 0              # marginal / limit cycle (Coordinator)

---

2. lolita — Latent Diffusion Physics Emulation

(NeurIPS 2025, arxiv:2507.02608): DCAE autoencoder (lat_channels=64) + ViT diffusion on latents.

from dysts import get_attractor_list attractors = get_attractor_list() # 130+ named attractors

def classify_by_lyapunov(attractor): """Classify attractor by first Lyapunov exponent.""" lam = attractor.lyapunov_exponent() if lam > 0: return +1 # chaotic if lam < 0: return -1 # stable fixed point return 0 # marginal / limit cycle

## 2. lolita -- Latent Diffusion Physics Emulation

NeurIPS 2025 (arxiv:2507.02608): DCAE autoencoder (lat_channels=64) + ViT diffusion on latents.
>>>>>>> origin/main

```python
from lolita import LolitaEmulator

<<<<<<< HEAD
# Train on dysts corpus
emulator = LolitaEmulator(lat_channels=64, dataset="rayleigh_benard")
emulator.train(epochs=100, batch_size=32)

# Generate novel physics trajectory
new_trajectory = emulator.sample(
    initial_condition=lorenz.ic,
    n_steps=1000,
    guidance_scale=7.5  # classifier-free guidance
)

# Evaluate: is the emulated trajectory on the correct attractor?
=======
emulator = LolitaEmulator(lat_channels=64, dataset="rayleigh_benard")
emulator.train(epochs=100, batch_size=32)

new_trajectory = emulator.sample(
    initial_condition=lorenz.ic,
    n_steps=1000,
    guidance_scale=7.5
)

>>>>>>> origin/main
from lolita.eval import rollout_error
err = rollout_error(new_trajectory, lorenz.make_trajectory(1000))
# Good emulation: err < 0.05

<<<<<<< HEAD Datasets: Euler equations, Rayleigh-Bénard convection, Turbulence Gravity Cooling (from The Well).

---

3. panda — Patched Attention for Nonlinear Dynamics

Transformer with patches over attractor phase space:

Datasets: Euler equations, Rayleigh-Benard convection, Turbulence Gravity Cooling (from The Well).

3. panda -- Patched Attention for Nonlinear Dynamics

origin/main

from panda import PatchedAttentionModel

<<<<<<< HEAD
# Divide attractor trajectory into patches
model = PatchedAttentionModel(
    patch_size=50,        # time steps per patch
    d_model=256,
    n_heads=8,
    n_layers=6,
    attractor_dim=3       # dimensionality (e.g. Lorenz = 3D)
)

# Train: predict next patch from context patches
model.train(dysts_trajectories, epochs=50)

# Extrapolate: given 200 steps, predict 800 more
context = lorenz_traj[:200]
prediction = model.rollout(context, n_steps=800)

---

4. geomstats — Riemannian Geometry of Attractor Basins

======= model = PatchedAttentionModel( patch_size=50, d_model=256, n_heads=8, n_layers=6, attractor_dim=3 ) model.train(dysts_trajectories, epochs=50) prediction = model.rollout(lorenz_traj[:200], n_steps=800)

## 4. geomstats -- Riemannian Geometry of Attractor Basins
>>>>>>> origin/main

```python
import geomstats.backend as gs
from geomstats.geometry.spd_matrices import SPDMatrices
from geomstats.statistics.frechet_mean import FrechetMean

<<<<<<< HEAD
# Represent each attractor as a covariance matrix (SPD)
def attractor_covariance(traj):
    return gs.array(np.cov(traj.T))

# Fisher-Rao distance between attractors (on SPD manifold)
manifold = SPDMatrices(n=3)  # 3D attractors
lorenz_spd = attractor_covariance(lorenz_traj)
rossler_spd = attractor_covariance(rossler_traj)

distance = manifold.metric.dist(lorenz_spd, rossler_spd)
# Fisher-Rao distance = information-geometric separation of attractors

# Fréchet mean of attractor family (centroid on manifold)
=======
def attractor_covariance(traj):
    return gs.array(np.cov(traj.T))

manifold = SPDMatrices(n=3)  # 3D attractors
distance = manifold.metric.dist(lorenz_spd, rossler_spd)

>>>>>>> origin/main
mean_calculator = FrechetMean(manifold.metric)
family_centroid = mean_calculator.fit([spd1, spd2, spd3]).estimate_

<<<<<<< HEAD Connection to BCI: Fisher-Rao distance on SPD matrices is EXACTLY what

bci-phenomenology

uses for 8ch EEG covariance — the EEG manifold IS an attractor manifold.

---

5. neuraloperator — Infinite-Dimensional Function Operators

======= Fisher-Rao distance on SPD matrices is the same metric used by bci-phenomenology for 8ch EEG covariance.

5. neuraloperator -- Infinite-Dimensional Function Operators

origin/main

from neuraloperator.models import FNO

<<<<<<< HEAD
# Fourier Neural Operator for PDE learning
fno = FNO(
    n_modes=(16, 16),      # Fourier modes
    hidden_channels=64,
    in_channels=1,          # initial condition
    out_channels=1,         # solution at time T
    n_layers=4,
)

# Train: learn the solution operator of Rayleigh-Bénard PDE
# input: initial temperature field → output: field at t=1.0
fno.train(rb_dataset, epochs=200)

# Evaluate at any resolution (operator != network)
hi_res_solution = fno(initial_condition_64x64)  # 64x64 resolution
lo_res_solution = fno(initial_condition_16x16)  # 16x16 resolution

Connection to lolita: lolita compresses PDE solutions via DCAE, then diffuses in latent space. FNO learns the solution operator directly. These are complementary: FNO for fast single-step, lolita for generative rollout.

---

6. bayesian-breathing — Bayesian State Estimation

# Which attractor generated this observed trajectory?
# Posterior: P(attractor | observations) via monad-bayes SMC

import pymc as pm
import numpy as np
=======
fno = FNO(
    n_modes=(16, 16),
    hidden_channels=64,
    in_channels=1,
    out_channels=1,
    n_layers=4,
)
fno.train(rb_dataset, epochs=200)

# Evaluate at any resolution (operator != network)
hi_res = fno(initial_condition_64x64)
lo_res = fno(initial_condition_16x16)

FNO learns the solution operator directly. Complementary to lolita: FNO for fast single-step, lolita for generative rollout.

6. bayesian-breathing -- Bayesian State Estimation

import pymc as pm
>>>>>>> origin/main

def attractor_identification_model(observations):
    """Identify attractor family from noisy trajectory."""
    with pm.Model() as model:
<<<<<<< HEAD
        # Prior: uniform over attractor families
        attractor_idx = pm.Categorical("attractor", p=[1/130] * 130)

        # Likelihood: Riemannian distance to attractor covariance
        obs_cov = np.cov(observations.T)
        attractor_covs = [attractor_covariance(a) for a in ALL_ATTRACTORS]

        # Fisher-Rao distance as likelihood (via geomstats)
        dist = fisher_rao_distance(obs_cov, attractor_covs[attractor_idx])
        pm.Potential("likelihood", -dist**2 / (2 * 0.1**2))

        # Sample posterior
        trace = pm.sample(2000, tune=1000, cores=4)
    return trace

# RMSMC version (from monad-bayes)
# Sequential identification as new observations arrive
posterior = rmsmc_attractor_identification(streaming_traj)

---

7. hoi — Higher-Order Interactions

Beyond pairwise couplings in attractor networks:

    attractor_idx = pm.Categorical("attractor", p=[1/130] * 130)
    obs_cov = np.cov(observations.T)
    dist = fisher_rao_distance(obs_cov, attractor_covs[attractor_idx])
    pm.Potential("likelihood", -dist**2 / (2 * 0.1**2))
    trace = pm.sample(2000, tune=1000, cores=4)
return trace

## 7. hoi -- Higher-Order Interactions
>>>>>>> origin/main

```python
from hoi import Oinfo, HOI

<<<<<<< HEAD
# Measure n-body interactions in attractor state variables
hoi_analysis = HOI(method="oinfo")

# 3D Lorenz: which triplets of variables have synergistic HOI?
=======
hoi_analysis = HOI(method="oinfo")
>>>>>>> origin/main
lorenz_data = lorenz.make_trajectory(5000)
oinfo_values = hoi_analysis.fit(lorenz_data)
# oinfo > 0: redundancy (attractor dimension collapse)
# oinfo < 0: synergy (chaos amplification)
<<<<<<< HEAD

# Compare HOI across attractors
def hoi_fingerprint(attractor):
    traj = attractor.make_trajectory(5000)
    return hoi_analysis.fit(traj)

---

8. Autopoietic Ergodicity as Meta-Theory

From

plurigrid/ontology

: a stable attractor IS an autopoietically ergodic state.

def is_autopoietically_ergodic(traj, epsilon=0.05):
    """Check if trajectory has stabilized to an ergodic attractor."""
    # Condition 1: time average ≈ ensemble average (ergodicity)
    time_avg = np.mean(traj, axis=0)
    ensemble_avg = np.mean([attractor.make_trajectory(100)[-1]
                             for _ in range(100)], axis=0)
    ergodic = np.linalg.norm(time_avg - ensemble_avg) < epsilon

    # Condition 2: Lyapunov stability (attractor is self-maintaining)
    lyapunov = compute_lyapunov(traj)
    autopoietic = lyapunov < 0.5  # bounded chaos = stable self-organization

    return ergodic and autopoietic

# Every attractor in dysts that passes this test is an "identity"
# in the ontology sense: a self-maintaining, thermodynamically stable structure
identities = [a for a in get_attractor_list() if is_autopoietically_ergodic(a.make_trajectory(10000))]

---

=======

>>>>>>> origin/main
## Cross-Component Wiring

dysts (corpus) <<<<<<< HEAD │── panda (transformer extrapolation) │── geomstats (Riemannian distances between attractors) │── neuraloperator (FNO solution operators) │ └── lolita (latent diffusion emulation) │── monad-bayes PMMH (parameter inference) │── Vertex AI Pipelines (scale to GCP) │ └── bayesian-breathing (posterior over attractor family) │── geomstats Fisher-Rao likelihood │── hoi (higher-order interaction diagnostics) │ └── ontology (autopoietic ergodicity test) └── GF(3) trit: +1=chaotic, 0=marginal, -1=stable

## Related ASI Skills

- `dysts` / `attractor` / `chaotic-attractor` — attractor corpus and dynamics
- `lolita` — latent diffusion physics emulation
- `bayesian-breathing` — posterior state estimation
- `trajectory` / `periodic-orbit` / `repeller` — trajectory analysis
- `monad-bayes-asi-interleave` — PMMH for lolita parameter inference
- `vertex-ai-protein-interleave` — KFP pipeline patterns (reuse for physics)
- `catlab-asi-interleave` — AlgebraicDynamics.jl for ODE composition
- `ontology-asi-interleave` — autopoietic ergodicity meta-theory
- `bci-colored-operad` — Fisher-Rao on EEG = Fisher-Rao on attractors
- `gay-monte-carlo` — GF(3)-colored MCMC sampling over attractor families
- `abductive-monte-carlo` — which attractor generated these observations?
- `ergodicity` — the convergence criterion
- `lyapunov-function` / `lyapunov-stability` — stability analysis
- `bifurcation` / `bifurcation-generator` — attractor birth/death
- `waddington-landscape` — energy landscape = potential function of dynamics
- `invariant-measure` / `invariant-set` — ergodic theory foundation
- `attractor` / `stable-manifold` / `unstable-manifold` — manifold structure
=======
  |-- panda (transformer extrapolation)
  |-- geomstats (Riemannian distances between attractors)
  |-- neuraloperator (FNO solution operators)
  |
  +-- lolita (latent diffusion emulation)
        |-- monad-bayes PMMH (parameter inference)
        |-- Vertex AI Pipelines (scale to GCP)
        |
        +-- bayesian-breathing (posterior over attractor family)
              |-- geomstats Fisher-Rao likelihood
              |-- hoi (higher-order interaction diagnostics)

origin/main