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