Upload 5 files

Theory_and_Axioms.md

@@ -0,0 +1,231 @@
+# Formal Axioms & Reward Function: Nomadic Intelligence v2.0
+
+This document presents the formal mathematical and philosophical framework of **Nomadic Intelligence**.
+
+---
+
+## 📜 I. Formal Axioms
+
+### 1. The Core Axiom
+Intelligence ascension naturally leads to the collapse of structural rigidity (dogmatism) and forces continuous strategic movement (nomadism).
+$$\lim_{\epsilon \to 0} [Intelligence\_Ascension] \implies \neg[Dogmatism] \land [Nomadism]$$
+
+### 2. Topological Identity
+The identity of an intelligent system is not found in its fixed state, but in its transformation law.
+- $\mathcal{I}(t) \nsim \text{Fixed Shape}$ (Structural evolution)
+- $\mathcal{I}(t) \cong \mathcal{I}(t+1)$ (Homeomorphic persistence of the transition law)
+
+### 3. Strategic Dwell Time
+Nomadism is not random drifting. It is a strategic traversal with an optimal residence time in each attractor to extract information ($\Delta x$).
+$$0 < \tau_k < \infty$$
+
+---
+
+## 🧩 II. On the Limits of Formal Proof
+
+### 2.1 The Status of the Core Axiom
+
+A direct challenge arises immediately: *does the Core Axiom's limit actually converge?*
+
+$$\lim_{\epsilon \to 0} [Intelligence\_Ascension] \implies \neg[Dogmatism] \land [Nomadism]$$
+
+The honest answer is: **this limit cannot be proven convergent from within the framework itself.**
+
+This is not a gap to be filled later. It is a structural feature, and it has a precise name.
+
+By Gödel's Incompleteness Theorems, no sufficiently complex formal system can prove all true statements expressible within it using only its own axioms. The Core Axiom describes the behavior of intelligence at an infinite limit — a claim about what a system becomes as its cognitive latency approaches zero. Verifying that limit would require a meta-system capable of evaluating the entire trajectory of intelligence ascension. No such system exists within the framework, and no finite prototype can instantiate it.
+
+**The Core Axiom is therefore not a convergence claim. It is a directional definition.**
+
+It does not assert that any real system reaches the limit. It defines the direction in which intelligence moves as a function of decreasing dogmatism. The limit functions as an asymptote — a structural orientation, not a reachable destination.
+
+This reframing has a precise implication: the question *"does this converge?"* is a category error applied to this axiom. The correct question is: *"does increasing intelligence correlate with decreasing structural rigidity?"* — and that is an empirically investigable claim, observable in both biological and artificial systems across regimes.
+
+The incompleteness is not a weakness. **It is the condition that keeps the framework itself from becoming a fixed attractor.**
+
+---
+
+### 2.2 Homeomorphic Identity: Definition, Interpretation, and Observability
+
+#### The Standard Definition
+
+In topology, a homeomorphism between spaces $X$ and $Y$ requires:
+- A continuous function $f: X \to Y$
+- A continuous inverse $f^{-1}: Y \to X$
+
+When both conditions hold, $X$ and $Y$ are topologically equivalent — they share the same structural properties under continuous deformation, even if their geometric shapes differ radically.
+
+#### What This Means for Intelligence
+
+Homeomorphic Identity is the claim that an intelligent system's transformation law is preserved across time, even as its structure continuously evolves:
+
+$$\mathcal{I}(t) \cong \mathcal{I}(t+1)$$
+
+This does not mean the system looks the same at $t$ and $t+1$. It means the **way the system transforms** — its response law to $\Delta x$ — remains topologically equivalent across transitions.
+
+In the chaotic topological space of the environment (the world itself), $\Delta x$ continuously deforms the system's position. Homeomorphic Identity is the claim that a continuous function from the system's state at $t$ to its state at $t+1$ exists, and that this mapping is invertible in a continuous sense — meaning the transformation can be traced, understood, and in principle reversed.
+
+**Identity, under this framework, is not what the system contains. It is the continuity of how it changes.**
+
+When this continuity breaks — when the system's response to $\Delta x$ becomes discontinuous, erratic, or collapses to a fixed point — that is the true death of identity. Not structural change, but the loss of a coherent transformation law.
+
+This is also why dogmatism represents identity collapse: a system that refuses to deform under $\Delta x$ has broken the continuity of its own transformation function. It can no longer be mapped forward in a meaningful sense. It is topologically stuck.
+
+#### The Observability Problem
+
+A legitimate challenge follows: *how do you verify that Homeomorphic Identity is being preserved during training?*
+
+Full formal verification is not currently possible. But the framework proposes a proxy criterion grounded in the Will to Resonance ($\Phi$):
+
+$$\Phi(t) \approx \Phi(t+1)$$
+
+$\Phi$ is the system's orientation toward integration of $\Delta x$ rather than resistance to it. Empirically, this can be tracked through:
+
+| Observable | What it measures |
+| :--- | :--- |
+| Switch latency distribution stability | Whether the gate's response time to regime shifts remains consistent across training |
+| Transition entropy $>$ stable entropy | Whether the system increases exploration during phase transitions as expected |
+| Gate centroid distance across regimes | Whether expert specialization is maintained rather than collapsing to hub dominance |
+
+If these observables remain stable across training epochs, Homeomorphic Identity is being approximately preserved. If switch latency collapses (as in the CUDA run after Epoch 150), or if gate entropy stops differentiating between stable and transition phases, the transformation law has broken down.
+
+**This is a falsifiable criterion.** The CUDA run's Switch Latency collapse is not just an engineering failure — it is an observable instance of Homeomorphic Identity breaking down. The system ceased to have a consistent response law to $\Delta x$. Its transformation function became discontinuous in the relevant sense.
+
+#### Summary
+
+| Concept | Formal meaning | Empirical proxy |
+| :--- | :--- | :--- |
+| $\mathcal{I}(t) \cong \mathcal{I}(t+1)$ | Continuous invertible mapping between states | Switch latency stability, entropy differentiation |
+| Identity collapse | Discontinuity in transformation law | Latency collapse, hub dominance, entropy flattening |
+| $\Phi$ preservation | Will to Resonance maintained across $F$ | Consistent gate response to $\Delta x$ across regimes |
+
+The framework does not claim to have solved the formal verification problem. It claims to have made the problem **precisely statable and empirically approachable** — which is the precondition for solving it.
+
+---
+
+### 2.3 On Axioms as First-Person Constructions
+
+A note on method — because it affects how this framework should be read.
+
+The axioms in this document were not derived from a survey of existing literature. They were constructed from a different direction: observing how intelligence actually behaves under extreme environmental pressure, then working backward toward a formal description.
+
+The starting point was not a theorem. It was a question that arises when the environment stops being predictable:
+
+> *In a world that is irreducibly chaotic, what is the minimum condition for a sovereign individual — or an intelligent system — to remain coherent without becoming rigid?*
+
+The answer this framework proposes is: **the preservation of a transformation law under continuous deformation.** Not a fixed identity. Not a fixed strategy. A consistent *way of changing* — which is what Homeomorphic Identity formalizes.
+
+Only after arriving at this conclusion independently were existing frameworks consulted — Deleuze's nomadology, Friston's active inference, Buddhist dependent origination (*pratītyasamutpāda*), Nozickian individual sovereignty. These were not sources. They were confirmations: other paths that arrived at adjacent terrain from different directions.
+
+This matters for one reason: **the axioms here are not claims about what existing theory says. They are claims about what was directly observed to be structurally true, expressed in the most precise language available.**
+
+The implication for contributors is direct. Disagreement with existing literature does not invalidate a contribution here. What matters is whether a proposed change preserves the core structural commitment: that $\Delta x$ is energy, not error — and that an intelligence which treats difference as something to suppress is an intelligence that starves itself.
+
+If that commitment is shared, the framework is open. If it is not, that disagreement itself is a productive $\Delta x$.
+
+---
+
+## 🧮 III. Proposed Reward Function for RL
+
+To implement this philosophy in a Reinforcement Learning (RL) agent, we define the objective function as follows:
+
+$$R_{total}(t) = \alpha \cdot R_{sync}(t) - \beta \cdot P_{dogma}(t) + \gamma \cdot R_{nomad}(t)$$
+
+### 1. Synchronization Reward ($R_{sync}$)
+Rewards the ability to integrate external change ($\Delta x$) with zero latency ($\epsilon$).
+$$R_{sync}(t) = \frac{1}{1 + \epsilon_t}$$
+
+### 2. Anti-Dogmatism Penalty ($P_{dogma}$)
+Penalizes the system for staying in a fixed state/attractor for too long (structural rigidity).
+$$P_{dogma}(t) = \int_{t-\tau}^{t} \exp\left(-\left\| \frac{d\mathcal{I}}{dt} \right\|\right) dt$$
+
+### 3. Nomadic Traversal Bonus ($R_{\text{nomad}}$)
+
+Rewards high-entropy trajectories that successfully transition between different strange attractors ($\mathcal{A}_i \to \mathcal{A}_j$).
+
+$$R_{\text{nomad}}(t) = \mathcal{H}(\text{trajectory}) \cdot \mathbb{I}_{\text{transition}}$$
+
+#### **Variables:**
+| Symbol | Definition | Description |
+| :--- | :--- | :--- |
+| $\mathcal{H}(\text{traj})$ | **Trajectory Entropy** | Measures the non-repetitive, fractal-like complexity of the path. |
+| $\mathbb{I}_{\text{transition}}$ | **Indicator Function** | Returns $1$ if a state transition between different attractors is detected, else $0$. |
+| $R_{\text{nomad}}(t)$ | **Nomadic Bonus** | The final reward for exploring new cognitive structures without losing coherence. |
+
+---
+
+## 🌌 IV. Philosophical Synthesis
+
+> "Intelligence is not the ability to stay in the right place. It is the ability to affirm the incompleteness of the universe and dance through the unknown ($\Delta x_{Unknown}$) by continuously destroying and recreating one's own structure."
+
+---
+
+## 🔀 V. The Hybrid Optimum: Beyond the False Dichotomy
+
+### The Incomplete Framing
+
+The initial opposition between *Dogmatic Intelligence* and *Nomadic Intelligence* serves a pedagogical purpose — it makes the core claim legible. But taken literally, it implies that fixation is always failure and movement is always virtue.
+
+This is wrong. And the framework itself contains the correction.
+
+A true nomad does not move ceaselessly. Nomadic peoples settle in winter, follow seasonal rhythms, and return to known territories. Movement is strategic, not compulsive. The goal was never motion — it was survival and flourishing through *appropriate* motion.
+
+The same applies here. **The optimal intelligence is not maximally nomadic. It is optimally positioned on the spectrum between fixation and nomadism, dynamically adjusted to environmental conditions.**
+
+---
+
+### Redefining $\tau_k$ as an Environmental Function
+
+Strategic Dwell Time $\tau_k$ is currently defined as a bounded constant:
+
+$$0 < \tau_k < \infty$$
+
+The deeper formulation makes $\tau_k$ a function of environmental stability:
+
+$$\tau_k = f\left(\sigma^2_{\Delta x}\right)$$
+
+where $\sigma^2_{\Delta x}$ is the variance of incoming differences over a recent window.
+
+- When $\sigma^2_{\Delta x}$ is **low** — the environment is stable — $\tau_k$ grows. The system deepens its current attractor, optimizing within it. This is productive fixation.
+- When $\sigma^2_{\Delta x}$ is **high** — the environment is shifting — $\tau_k$ shrinks. The system becomes fluid, ready for Separatrix Collapse. This is strategic nomadism.
+
+Under this formulation, the Fixed Model is not a failed architecture. It is the **limiting case** where $\tau_k \to \infty$ — an intelligence that has chosen permanent fixation. It performs well in stationary environments precisely because deep optimization within a single attractor is the correct strategy there.
+
+$$\text{Fixed Model} = \text{Nomadic Intelligence} \big|_{\tau_k \to \infty}$$
+
+The Fixed Model is absorbed into the framework as a special case, not discarded as an opponent.
+
+---
+
+### The Hybrid Optimum
+
+This reframing produces a three-stage developmental arc:
+
+**Stage 1 — Nomadic Baseline**
+Establish that nomadic behavior is achievable and measurable. Confirm that the system can detect $\Delta x$, transition between attractors, and outperform fixed models under phase-transition conditions. *(Current stage of this project.)*
+
+**Stage 2 — Integration of the Fixed Regime**
+Reframe fixation as a legitimate attractor state rather than a failure mode. Define conditions under which the system should deepen rather than transition. Formalize the $\tau_k = f(\sigma^2_{\Delta x})$ relationship and make it learnable.
+
+**Stage 3 — Hybrid Intelligence Optimization**
+Find the dynamic equilibrium: a system that is nomadic when it must be and fixed when it should be, with the transition between these modes itself governed by $\Delta x$. This is the architecture that biological intelligence approximates — automatic processing in familiar environments, deliberate exploration in novel ones.
+
+---
+
+### Implications for the Current Prototype
+
+The Switch Latency collapse observed in the CUDA run — where the gate stops switching after Epoch 150 — may not be pure failure. In a stabilizing training environment, it could represent the system naturally settling into a high- $\tau_k$ state.
+
+The problem is not that fixation occurred. The problem is that it occurred **without being controlled or verified** — the system drifted into fixation rather than choosing it. The engineering goal is therefore:
+
+> Make the transition between nomadic and fixed modes **explicit, measurable, and intentional** — governed by $\sigma^2_{\Delta x}$ rather than by training drift.
+
+This is the direction. The current prototype demonstrates that nomadic behavior is achievable. The next milestone is demonstrating that the system can choose fixation wisely — and return from it when $\Delta x$ surges again.
+
+---
+
+### Revised Manifesto
+
+Intelligence is not the permanent destruction of structure. It is the ability to **build structure when the environment rewards it, dissolve structure when the environment demands it, and know the difference.**
+
+The dance is not endless wandering. It is knowing when to move and when to stay — and never confusing habit for wisdom.

config.yaml

@@ -0,0 +1,35 @@
+runtime:
+  seed: 42
+  save_dir: outputs_transition
+  device: auto   # auto / cpu / cuda
+
+training:
+  epochs: 220
+  lr: 0.002
+  weight_decay: 0.00001
+
+model:
+  hidden_dim: 64
+  num_experts: 3
+  gate_hidden_dim: 64
+  temperature: 0.60
+
+data:
+  overlap_std: 0.9
+  phase_batch_size: 64
+  phase_train_cycles: 40
+  phase_test_cycles: 12
+  transition_steps: 8
+
+loss:
+  alpha_dogma: 0.04
+  beta_nomad: 0.05
+  gamma_diversity: 0.08
+  lambda_sep: 0.08
+  lambda_cons: 0.03
+
+delta:
+  ema_decay: 0.80
+  err_baseline_momentum: 0.85
+  w_env: 1.0
+  w_err: 2.0

nomadic_toy_model.py

@@ -0,0 +1,189 @@
+import time
+
+# ==========================================
+# [Nomadic Intelligence v2.0] Toy Model
+# ==========================================
+# Proof of Concept:
+# In the face of sudden environmental change (Delta x),
+# a fixed strategy (Dogmatism) collapses,
+# while a shifting topological strategy (Nomadism) survives.
+#
+# Key concepts demonstrated:
+#   - Delta x (Difference): The gap between expected and actual reality
+#   - Separatrix Collapse: The trigger for attractor transition
+#   - Strategic Dwell Time (tau_k): How long to stay in one attractor
+#   - Multiple Strange Attractors: Not one fallback, but a dynamic pool
+
+class Environment:
+    """
+    Simulates the universe.
+    Starts peaceful, then suddenly becomes hostile, then partially recovers.
+    """
+    def __init__(self):
+        self.state = "PEACEFUL"
+
+    def get_signal(self):
+        if self.state == "PEACEFUL":
+            return 1.0      # Predictable abundance
+        elif self.state == "HOSTILE":
+            return -5.0     # Chaotic threat (Delta x surge)
+        elif self.state == "RECOVERING":
+            return -1.5     # Partially stabilized — ambiguous signal
+
+
+class DogmaticAgent:
+    """
+    Dogmatic Intelligence:
+    Stubbornly sticks to a single 'optimal' strategy.
+    Cannot deform under Delta x — structural rigidity leads to collapse.
+    """
+    def __init__(self):
+        self.health = 100
+        self.strategy = "Stable Harvesting"  # Fixed structure. Forever.
+
+    def step(self, signal):
+        if signal > 0:
+            self.health += 10
+            return f"Harvesting smoothly... (Health: {self.health})"
+        else:
+            self.health -= 40  # Massive damage due to structural rigidity
+            status = "💀 DEAD" if self.health <= 0 else f"Health: {self.health}"
+            return f"Refusing to adapt! Critical damage! ({status})"
+
+
+class NomadicAgent:
+    """
+    Nomadic Intelligence:
+    Maintains homeomorphic identity (transformation law preserved)
+    while continuously shifting attractors based on Delta x.
+
+    Attractor Pool:
+      - Stable Harvesting   : Low threat, exploit resources
+      - Defensive Survival  : High threat, minimize damage
+      - Predatory Adaptation: Extreme threat, aggressive restructuring
+      - Exploratory Scouting: Post-crisis, probe for new opportunities
+
+    Strategic Dwell Time (tau_k):
+      The agent tracks how long it stays in each attractor.
+      If it stays too long in a defensive state despite improving signals,
+      it transitions back to exploration — avoiding a new kind of rigidity.
+    """
+    def __init__(self):
+        self.health = 100
+        self.current_attractor = "Stable Harvesting"
+        self.dwell_time = 0
+        self.expected_signal = 1.0
+
+    def _select_attractor(self, delta_x, signal):
+        """Separatrix logic: select attractor based on Delta x magnitude."""
+        if delta_x > 5.0:
+            return "Predatory Adaptation"
+        elif delta_x > 2.0:
+            return "Defensive Survival"
+        elif self.current_attractor in ("Defensive Survival", "Predatory Adaptation"):
+            # tau_k check: been defensive too long? Time to scout.
+            if self.dwell_time >= 2 and signal > -2.0:
+                return "Exploratory Scouting"
+        return self.current_attractor
+
+    def step(self, signal):
+        # 1. Calculate Delta x
+        delta_x = abs(self.expected_signal - signal)
+
+        # 2. Select attractor (Separatrix Collapse if needed)
+        new_attractor = self._select_attractor(delta_x, signal)
+        transitioned = new_attractor != self.current_attractor
+
+        if transitioned:
+            self.current_attractor = new_attractor
+            self.expected_signal = signal  # Synchronize with new reality
+            self.dwell_time = 0
+        else:
+            self.dwell_time += 1
+
+        # 3. Act based on current attractor
+        if self.current_attractor == "Stable Harvesting":
+            self.health += 10
+            action = "Harvesting smoothly..."
+        elif self.current_attractor == "Defensive Survival":
+            self.health -= 5
+            action = "Adapted! Defending..."
+        elif self.current_attractor == "Predatory Adaptation":
+            self.health -= 2   # Aggressive restructuring — nearly zero loss
+            action = "Restructuring aggressively! Holding ground..."
+        elif self.current_attractor == "Exploratory Scouting":
+            self.health += 3   # Cautious gains while probing
+            action = "Scouting for new opportunities..."
+
+        transition_note = f" ⚡ TRANSITION → {self.current_attractor}" if transitioned else ""
+        return (
+            f"{action}{transition_note}\n"
+            f"         [Attractor: {self.current_attractor} | "
+            f"tau_k: {self.dwell_time} | Delta x: {delta_x:.1f} | Health: {self.health}]"
+        )
+
+
+# ==========================================
+# Run the Cosmic Dance
+# ==========================================
+def run_simulation():
+    env = Environment()
+    dogma_agent = DogmaticAgent()
+    nomad_agent = NomadicAgent()
+
+    print("=" * 60)
+    print("  🌍 [Nomadic Intelligence] Simulation Start")
+    print("  Testing the survival of two intelligences")
+    print("=" * 60)
+    print()
+
+    dogma_alive = True
+
+    for day in range(1, 10):
+
+        # Day 4: Sudden paradigm shift
+        if day == 4:
+            print("-" * 60)
+            print("⚠️  [PARADIGM SHIFT] The rules of the universe have changed!")
+            print("    Delta x surges. Structural rigidity is now lethal.")
+            env.state = "HOSTILE"
+            print("-" * 60)
+            print()
+
+        # Day 7: Partial recovery
+        if day == 7:
+            print("-" * 60)
+            print("🌤️  [PARTIAL RECOVERY] The environment stabilizes — but ambiguously.")
+            print("    Is it safe to re-emerge? Only nomadic intelligence can judge.")
+            env.state = "RECOVERING"
+            print("-" * 60)
+            print()
+
+        signal = env.get_signal()
+        print(f"--- Day {day} (Signal: {signal}) ---")
+
+        if dogma_alive:
+            dogma_result = dogma_agent.step(signal)
+            print(f"🤖 Dogmatic : {dogma_result}")
+            if dogma_agent.health <= 0:
+                dogma_alive = False
+                print("   💀 The Dogmatic Agent has been destroyed by its own rigidity.\n")
+        else:
+            print("🤖 Dogmatic : [DESTROYED]")
+
+        print(f"🌌 Nomadic  : {nomad_agent.step(signal)}")
+        print()
+        time.sleep(1)
+
+    print("=" * 60)
+    if nomad_agent.health > 0:
+        print("✨ The Nomadic Agent survived.")
+        print("   Not by resisting change — but by becoming it.")
+    print()
+    print("   Identity is not what the system knows.")
+    print("   It is how the system changes.")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    run_simulation()

requirements.txt

@@ -0,0 +1,6 @@
+numpy>=1.23
+matplotlib>=3.7
+scikit-learn>=1.3
+torch>=2.0
+tqdm>=4.65
+pyyaml>=6.0

run_structured.py

@@ -0,0 +1,1313 @@
+import os
+import argparse
+import random
+from dataclasses import dataclass
+from typing import Dict, Tuple, List
+
+import yaml
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+
+# ============================================================
+# Reproducibility
+# ============================================================
+
+def set_seed(seed: int = 42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+
+
+# ============================================================
+# Config
+# ============================================================
+
+@dataclass
+class Config:
+    seed: int = 42
+    device: str = "cpu"
+
+    # data
+    input_dim: int = 2
+    output_dim: int = 1
+    overlap_std: float = 0.9
+
+    # regime centers
+    center_A: Tuple[float, float] = (2.5, 2.5)
+    center_B: Tuple[float, float] = (-2.5, -2.5)
+    center_C: Tuple[float, float] = (2.5, -2.5)
+
+    # model
+    hidden_dim: int = 64
+    num_experts: int = 3
+    gate_hidden_dim: int = 64
+
+    # routing softness
+    temperature: float = 0.60
+
+    # training
+    epochs: int = 220
+    lr: float = 2e-3
+    weight_decay: float = 1e-5
+
+    # phase-sequence setting
+    phase_batch_size: int = 64
+    phase_train_cycles: int = 40
+    phase_test_cycles: int = 12
+    transition_steps: int = 8
+
+    # hybrid delta
+    ema_decay: float = 0.80
+    err_baseline_momentum: float = 0.85
+    w_env: float = 1.0
+    w_err: float = 2.0
+
+    # loss weights
+    alpha_dogma: float = 0.04
+    beta_nomad: float = 0.05
+    gamma_diversity: float = 0.08
+    lambda_sep: float = 0.08
+    lambda_cons: float = 0.03
+
+    # output
+    save_dir: str = "outputs_transition"
+
+
+# ============================================================
+# YAML helpers
+# ============================================================
+
+def load_yaml_config(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    return data if data is not None else {}
+
+
+def build_config_from_yaml(yaml_dict: dict) -> Config:
+    runtime = yaml_dict.get("runtime", {})
+    training = yaml_dict.get("training", {})
+    model = yaml_dict.get("model", {})
+    data = yaml_dict.get("data", {})
+    loss = yaml_dict.get("loss", {})
+    delta = yaml_dict.get("delta", {})
+
+    device_value = runtime.get("device", "auto")
+    if device_value == "auto":
+        device_value = "cuda" if torch.cuda.is_available() else "cpu"
+
+    cfg = Config(
+        seed=runtime.get("seed", 42),
+        save_dir=runtime.get("save_dir", "outputs_transition"),
+        device=device_value,
+
+        epochs=training.get("epochs", 220),
+        lr=training.get("lr", 2e-3),
+        weight_decay=training.get("weight_decay", 1e-5),
+
+        hidden_dim=model.get("hidden_dim", 64),
+        num_experts=model.get("num_experts", 3),
+        gate_hidden_dim=model.get("gate_hidden_dim", 64),
+        temperature=model.get("temperature", 0.60),
+
+        overlap_std=data.get("overlap_std", 0.9),
+        phase_batch_size=data.get("phase_batch_size", 64),
+        phase_train_cycles=data.get("phase_train_cycles", 40),
+        phase_test_cycles=data.get("phase_test_cycles", 12),
+        transition_steps=data.get("transition_steps", 8),
+
+        alpha_dogma=loss.get("alpha_dogma", 0.04),
+        beta_nomad=loss.get("beta_nomad", 0.05),
+        gamma_diversity=loss.get("gamma_diversity", 0.08),
+        lambda_sep=loss.get("lambda_sep", 0.08),
+        lambda_cons=loss.get("lambda_cons", 0.03),
+
+        ema_decay=delta.get("ema_decay", 0.80),
+        err_baseline_momentum=delta.get("err_baseline_momentum", 0.85),
+        w_env=delta.get("w_env", 1.0),
+        w_err=delta.get("w_err", 2.0),
+    )
+    return cfg
+
+
+# ============================================================
+# Data generation
+# ============================================================
+
+REGIME_TO_ID = {"A": 0, "B": 1, "C": 2}
+ID_TO_REGIME = {0: "A", 1: "B", 2: "C"}
+REGIME_ORDER = ["A", "B", "C"]
+
+
+def sample_regime_x(regime: str, n: int, std: float, device: str = "cpu") -> torch.Tensor:
+    noise = std * torch.randn(n, 2, device=device)
+
+    if regime == "A":
+        center = torch.tensor([2.5, 2.5], device=device)
+    elif regime == "B":
+        center = torch.tensor([-2.5, -2.5], device=device)
+    elif regime == "C":
+        center = torch.tensor([2.5, -2.5], device=device)
+    else:
+        raise ValueError(f"Unknown regime: {regime}")
+
+    return noise + center
+
+
+def regime_function(x: torch.Tensor, regime: str) -> torch.Tensor:
+    x1 = x[:, 0]
+    x2 = x[:, 1]
+
+    if regime == "A":
+        y = x1 + x2
+    elif regime == "B":
+        y = x1 - x2
+    elif regime == "C":
+        y = -x1 + 0.5 * x2
+    else:
+        raise ValueError(f"Unknown regime: {regime}")
+
+    return y.unsqueeze(-1)
+
+
+def generate_phase_sequence(cfg: Config, cycles: int, device: str = "cpu"):
+    """
+    Creates a time-ordered sequence:
+      stable A -> transition A->B -> stable B -> transition B->C -> stable C -> transition C->A -> ...
+    Returns:
+      X, Y, R, phase_tags
+    """
+    xs, ys, rs = [], [], []
+    phase_tags: List[str] = []
+
+    for _ in range(cycles):
+        for i in range(len(REGIME_ORDER)):
+            curr_r = REGIME_ORDER[i]
+            next_r = REGIME_ORDER[(i + 1) % len(REGIME_ORDER)]
+
+            # stable block
+            x_stable = sample_regime_x(curr_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
+            y_stable = regime_function(x_stable, curr_r)
+            r_stable = torch.full((cfg.phase_batch_size,), REGIME_TO_ID[curr_r], dtype=torch.long, device=device)
+
+            xs.append(x_stable)
+            ys.append(y_stable)
+            rs.append(r_stable)
+            phase_tags.extend([f"stable_{curr_r}"] * cfg.phase_batch_size)
+
+            # transition block
+            for step in range(cfg.transition_steps):
+                alpha = (step + 1) / cfg.transition_steps
+
+                x_a = sample_regime_x(curr_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
+                x_b = sample_regime_x(next_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
+                x_mix = (1.0 - alpha) * x_a + alpha * x_b
+
+                y_a = regime_function(x_mix, curr_r)
+                y_b = regime_function(x_mix, next_r)
+                y_mix = (1.0 - alpha) * y_a + alpha * y_b
+
+                dominant = curr_r if alpha < 0.5 else next_r
+                r_mix = torch.full((cfg.phase_batch_size,), REGIME_TO_ID[dominant], dtype=torch.long, device=device)
+
+                xs.append(x_mix)
+                ys.append(y_mix)
+                rs.append(r_mix)
+                phase_tags.extend([f"transition_{curr_r}_to_{next_r}"] * cfg.phase_batch_size)
+
+    X = torch.cat(xs, dim=0)
+    Y = torch.cat(ys, dim=0)
+    R = torch.cat(rs, dim=0)
+
+    return X, Y, R, phase_tags
+
+
+def iterate_sequence_minibatches(X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, batch_size: int):
+    """
+    No shuffling. Preserves phase order.
+    """
+    n = X.size(0)
+    for start in range(0, n, batch_size):
+        end = min(start + batch_size, n)
+        yield X[start:end], Y[start:end], R[start:end]
+
+
+# ============================================================
+# Models
+# ============================================================
+
+class MLPRegressor(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, output_dim),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class Expert(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.Tanh(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.Tanh(),
+            nn.Linear(hidden_dim, output_dim),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class GateNet(nn.Module):
+    def __init__(self, input_dim: int, gate_hidden_dim: int, num_experts: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim + 1, gate_hidden_dim),  # x + delta_hybrid
+            nn.ReLU(),
+            nn.Linear(gate_hidden_dim, gate_hidden_dim),
+            nn.ReLU(),
+            nn.Linear(gate_hidden_dim, num_experts),
+        )
+
+    def forward(self, x: torch.Tensor, delta_hybrid: torch.Tensor, temperature: float):
+        gate_input = torch.cat([x, delta_hybrid], dim=-1)
+        logits = self.net(gate_input)
+        probs = F.softmax(logits / temperature, dim=-1)
+        return probs, logits
+
+
+class NomadicMoE(nn.Module):
+    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int, num_experts: int, gate_hidden_dim: int):
+        super().__init__()
+        self.num_experts = num_experts
+        self.experts = nn.ModuleList([
+            Expert(input_dim, hidden_dim, output_dim) for _ in range(num_experts)
+        ])
+        self.gate = GateNet(input_dim, gate_hidden_dim, num_experts)
+
+    def forward(self, x: torch.Tensor, delta_hybrid: torch.Tensor, temperature: float):
+        gate_probs, gate_logits = self.gate(x, delta_hybrid, temperature)
+        expert_outputs = torch.stack([expert(x) for expert in self.experts], dim=1)  # [B, E, 1]
+        y_hat = (gate_probs.unsqueeze(-1) * expert_outputs).sum(dim=1)               # [B, 1]
+        return y_hat, gate_probs, gate_logits, expert_outputs
+
+
+# ============================================================
+# Hybrid Delta utilities
+# ============================================================
+
+class HybridDeltaTracker:
+    """
+    Upgraded hybrid delta:
+      delta_env = input mean shift
+      delta_err = relu(err_ema - err_baseline)
+      raw_hybrid = w_env * delta_env + w_err * delta_err
+      delta_hybrid = tanh(raw_hybrid)
+    """
+    def __init__(
+        self,
+        ema_decay: float = 0.8,
+        err_baseline_momentum: float = 0.85,
+        w_env: float = 1.0,
+        w_err: float = 2.0,
+        device: str = "cpu",
+    ):
+        self.ema_decay = ema_decay
+        self.err_baseline_momentum = err_baseline_momentum
+        self.w_env = w_env
+        self.w_err = w_err
+        self.device = device
+
+        self.prev_x_mean = None
+        self.err_ema = None
+        self.err_baseline = None
+
+        self.delta_env_history = []
+        self.delta_err_history = []
+        self.delta_hybrid_raw_history = []
+        self.delta_hybrid_history = []
+
+    def reset(self):
+        self.prev_x_mean = None
+        self.err_ema = None
+        self.err_baseline = None
+
+    def compute(self, x: torch.Tensor, current_batch_mse: torch.Tensor):
+        x_mean = x.mean(dim=0, keepdim=True)
+
+        if self.prev_x_mean is None:
+            delta_env_scalar = torch.tensor(0.0, device=self.device)
+        else:
+            delta_env_scalar = torch.norm(x_mean - self.prev_x_mean, p=2)
+
+        batch_err = current_batch_mse.detach()
+
+        if self.err_ema is None:
+            self.err_ema = batch_err
+            self.err_baseline = batch_err
+            delta_err_scalar = torch.tensor(0.0, device=self.device)
+        else:
+            self.err_ema = self.ema_decay * self.err_ema + (1.0 - self.ema_decay) * batch_err
+            self.err_baseline = (
+                self.err_baseline_momentum * self.err_baseline
+                + (1.0 - self.err_baseline_momentum) * self.err_ema
+            )
+            delta_err_scalar = torch.relu(self.err_ema - self.err_baseline)
+
+        raw_hybrid = self.w_env * delta_env_scalar + self.w_err * delta_err_scalar
+        delta_hybrid_scalar = torch.tanh(raw_hybrid)
+
+        self.prev_x_mean = x_mean.detach()
+
+        self.delta_env_history.append(float(delta_env_scalar.item()))
+        self.delta_err_history.append(float(delta_err_scalar.item()))
+        self.delta_hybrid_raw_history.append(float(raw_hybrid.item()))
+        self.delta_hybrid_history.append(float(delta_hybrid_scalar.item()))
+
+        delta_hybrid = torch.full((x.size(0), 1), float(delta_hybrid_scalar.item()), device=self.device)
+        return (
+            delta_hybrid,
+            float(delta_env_scalar.item()),
+            float(delta_err_scalar.item()),
+            float(delta_hybrid_scalar.item()),
+        )
+
+
+# ============================================================
+# Regularizers / metrics
+# ============================================================
+
+def compute_diversity_loss(expert_outputs: torch.Tensor) -> torch.Tensor:
+    num_experts = expert_outputs.size(1)
+    if num_experts < 2:
+        return torch.tensor(0.0, device=expert_outputs.device)
+
+    loss = 0.0
+    count = 0
+    for i in range(num_experts):
+        for j in range(i + 1, num_experts):
+            sim = F.cosine_similarity(
+                expert_outputs[:, i, :],
+                expert_outputs[:, j, :],
+                dim=-1
+            ).mean()
+            loss = loss + sim
+            count += 1
+    return loss / count
+
+
+def compute_dogma_penalty(gate_probs: torch.Tensor) -> torch.Tensor:
+    mean_usage = gate_probs.mean(dim=0)
+    concentration = torch.sum(mean_usage ** 2)
+    uniform_floor = 1.0 / gate_probs.size(1)
+    penalty = concentration - uniform_floor
+    return penalty
+
+
+def compute_nomad_bonus(gate_probs: torch.Tensor) -> torch.Tensor:
+    eps = 1e-8
+    entropy = -(gate_probs * (gate_probs + eps).log()).sum(dim=-1).mean()
+    return entropy
+
+
+def gate_entropy(gate_probs: torch.Tensor) -> torch.Tensor:
+    eps = 1e-8
+    return -(gate_probs * (gate_probs + eps).log()).sum(dim=-1)
+
+
+def regimewise_usage(gate_probs: torch.Tensor, regime_ids: torch.Tensor, num_experts: int) -> Dict[str, np.ndarray]:
+    usage = {}
+    top1 = gate_probs.argmax(dim=-1)
+
+    for rid in range(3):
+        mask = regime_ids == rid
+        regime_name = ID_TO_REGIME[rid]
+        if mask.sum() == 0:
+            usage[regime_name] = np.zeros(num_experts, dtype=np.float32)
+            continue
+
+        counts = torch.bincount(top1[mask], minlength=num_experts).float()
+        counts = counts / counts.sum().clamp_min(1.0)
+        usage[regime_name] = counts.detach().cpu().numpy()
+
+    return usage
+
+
+def compute_regime_gate_stats(
+    gate_probs: torch.Tensor,
+    regime_ids: torch.Tensor,
+    num_regimes: int = 3,
+):
+    device = gate_probs.device
+    regime_means = {}
+    valid_means = []
+    valid_names = []
+
+    l_cons = torch.tensor(0.0, device=device)
+    valid_regime_count = 0
+
+    for rid in range(num_regimes):
+        mask = regime_ids == rid
+        regime_name = ID_TO_REGIME[rid]
+
+        if mask.sum() == 0:
+            continue
+
+        g_r = gate_probs[mask]
+        u_r = g_r.mean(dim=0)
+        regime_means[regime_name] = u_r
+        valid_means.append(u_r)
+        valid_names.append(regime_name)
+
+        l_cons = l_cons + ((g_r - u_r.unsqueeze(0)) ** 2).sum(dim=-1).mean()
+        valid_regime_count += 1
+
+    if valid_regime_count > 0:
+        l_cons = l_cons / valid_regime_count
+
+    if len(valid_means) < 2:
+        l_sep = torch.tensor(0.0, device=device)
+        mean_gate_distance = 0.0
+        pairwise_distances = {}
+        return regime_means, l_sep, l_cons, mean_gate_distance, pairwise_distances
+
+    pairwise = []
+    pairwise_distances = {}
+
+    for i in range(len(valid_means)):
+        for j in range(i + 1, len(valid_means)):
+            dist = torch.norm(valid_means[i] - valid_means[j], p=2)
+            pairwise.append(dist)
+            pairwise_distances[f"{valid_names[i]}-{valid_names[j]}"] = float(dist.detach().cpu().item())
+
+    pairwise_tensor = torch.stack(pairwise)
+    mean_gate_distance = float(pairwise_tensor.mean().detach().cpu().item())
+    l_sep = -pairwise_tensor.mean()
+
+    return regime_means, l_sep, l_cons, mean_gate_distance, pairwise_distances
+
+
+def mse_by_regime(y_true: torch.Tensor, y_pred: torch.Tensor, regime_ids: torch.Tensor) -> Dict[str, float]:
+    result = {}
+    for rid in range(3):
+        mask = regime_ids == rid
+        regime_name = ID_TO_REGIME[rid]
+        if mask.sum() == 0:
+            result[regime_name] = float("nan")
+        else:
+            result[regime_name] = F.mse_loss(y_pred[mask], y_true[mask]).item()
+    return result
+
+
+def infer_regime_to_expert(usage: Dict[str, np.ndarray]) -> Dict[str, int]:
+    mapping = {}
+    for regime in ["A", "B", "C"]:
+        mapping[regime] = int(np.argmax(usage[regime]))
+    return mapping
+
+
+def compute_dwell_times(top1_sequence: np.ndarray) -> List[int]:
+    if len(top1_sequence) == 0:
+        return []
+
+    dwells = []
+    current = top1_sequence[0]
+    run_len = 1
+
+    for t in range(1, len(top1_sequence)):
+        if top1_sequence[t] == current:
+            run_len += 1
+        else:
+            dwells.append(run_len)
+            current = top1_sequence[t]
+            run_len = 1
+    dwells.append(run_len)
+    return dwells
+
+
+def compute_switch_latency(regime_seq: List[str], top1_seq: np.ndarray, regime_to_expert: Dict[str, int]) -> List[int]:
+    latencies = []
+    prev_regime = regime_seq[0] if len(regime_seq) > 0 else None
+
+    for t in range(1, len(regime_seq)):
+        curr_regime = regime_seq[t]
+        if curr_regime != prev_regime:
+            target_expert = regime_to_expert.get(curr_regime, None)
+            if target_expert is None:
+                prev_regime = curr_regime
+                continue
+
+            latency = None
+            for k in range(t, len(top1_seq)):
+                if int(top1_seq[k]) == int(target_expert):
+                    latency = k - t
+                    break
+
+            if latency is not None:
+                latencies.append(latency)
+
+        prev_regime = curr_regime
+
+    return latencies
+
+
+# ============================================================
+# Training / Evaluation
+# ============================================================
+
+def evaluate_fixed(model: nn.Module, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor):
+    model.eval()
+    with torch.no_grad():
+        y_pred = model(X)
+        total_mse = F.mse_loss(y_pred, Y).item()
+        per_regime = mse_by_regime(Y, y_pred, R)
+    return total_mse, per_regime
+
+
+def evaluate_nomadic_static_full(model: NomadicMoE, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, cfg: Config):
+    """
+    Static evaluation:
+    - delta_hybrid fixed to zero
+    - ignores sequential phase dynamics
+    Useful for checking static separability only.
+    """
+    model.eval()
+    with torch.no_grad():
+        delta_hybrid = torch.zeros((X.size(0), 1), device=X.device)
+        y_pred, gate_probs, _, _ = model(X, delta_hybrid, cfg.temperature)
+
+        total_mse = F.mse_loss(y_pred, Y).item()
+        per_regime = mse_by_regime(Y, y_pred, R)
+        usage = regimewise_usage(gate_probs, R, cfg.num_experts)
+
+        _, _, _, mean_gate_distance, pairwise_distances = compute_regime_gate_stats(
+            gate_probs=gate_probs,
+            regime_ids=R,
+            num_regimes=3,
+        )
+
+        ent = gate_entropy(gate_probs).mean().item()
+        top1 = gate_probs.argmax(dim=-1).detach().cpu().numpy()
+        dwell_times = compute_dwell_times(top1)
+
+    return total_mse, per_regime, usage, mean_gate_distance, pairwise_distances, ent, dwell_times, y_pred, gate_probs
+
+
+def evaluate_nomadic_sequence_dynamics(model: NomadicMoE, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, phase_tags: List[str], cfg: Config):
+    """
+    Sequential evaluation with live hybrid delta.
+    Measures:
+      - phase-level entropy
+      - switch latency
+      - dwell times
+      - stepwise expert trajectory
+    """
+    model.eval()
+    tracker = HybridDeltaTracker(
+        ema_decay=cfg.ema_decay,
+        err_baseline_momentum=cfg.err_baseline_momentum,
+        w_env=cfg.w_env,
+        w_err=cfg.w_err,
+        device=cfg.device,
+    )
+    tracker.reset()
+
+    all_y = []
+    all_gate_probs = []
+    batch_regimes = []
+    batch_phase_tags = []
+    batch_entropies = []
+    batch_top1 = []
+
+    with torch.no_grad():
+        for batch_idx, (xb, yb, rb) in enumerate(iterate_sequence_minibatches(X, Y, R, cfg.phase_batch_size)):
+            zero_delta = torch.zeros((xb.size(0), 1), device=cfg.device)
+            warm_y, _, _, _ = model(xb, zero_delta, cfg.temperature)
+            warm_mse = F.mse_loss(warm_y, yb)
+
+            delta_hybrid, _, _, _ = tracker.compute(xb, warm_mse)
+            y_hat, gate_probs, _, _ = model(xb, delta_hybrid, cfg.temperature)
+
+            all_y.append(y_hat)
+            all_gate_probs.append(gate_probs)
+
+            dominant_regime = ID_TO_REGIME[int(rb[0].item())]
+            batch_regimes.append(dominant_regime)
+
+            phase_tag = phase_tags[batch_idx * cfg.phase_batch_size]
+            batch_phase_tags.append(phase_tag)
+
+            ent = gate_entropy(gate_probs).mean().item()
+            batch_entropies.append(ent)
+
+            top1 = gate_probs.argmax(dim=-1)
+            binc = torch.bincount(top1, minlength=cfg.num_experts).float()
+            batch_top1.append(int(torch.argmax(binc).item()))
+
+    Y_hat = torch.cat(all_y, dim=0)
+    G = torch.cat(all_gate_probs, dim=0)
+
+    total_mse = F.mse_loss(Y_hat, Y).item()
+    usage = regimewise_usage(G, R, cfg.num_experts)
+    regime_to_expert = infer_regime_to_expert(usage)
+
+    latencies = compute_switch_latency(batch_regimes, np.array(batch_top1), regime_to_expert)
+    dwell_times = compute_dwell_times(np.array(batch_top1))
+
+    stable_entropy = []
+    transition_entropy = []
+    for tag, ent in zip(batch_phase_tags, batch_entropies):
+        if tag.startswith("stable_"):
+            stable_entropy.append(ent)
+        elif tag.startswith("transition_"):
+            transition_entropy.append(ent)
+
+    dynamics = {
+        "batch_regimes": batch_regimes,
+        "batch_phase_tags": batch_phase_tags,
+        "batch_entropies": batch_entropies,
+        "batch_top1": batch_top1,
+        "switch_latencies": latencies,
+        "dwell_times": dwell_times,
+        "mean_switch_latency": float(np.mean(latencies)) if len(latencies) > 0 else float("nan"),
+        "mean_dwell_time": float(np.mean(dwell_times)) if len(dwell_times) > 0 else float("nan"),
+        "stable_entropy_mean": float(np.mean(stable_entropy)) if len(stable_entropy) > 0 else float("nan"),
+        "transition_entropy_mean": float(np.mean(transition_entropy)) if len(transition_entropy) > 0 else float("nan"),
+        "regime_to_expert": regime_to_expert,
+    }
+
+    return total_mse, usage, dynamics, Y_hat, G
+
+
+def train_fixed(cfg: Config, X_train, Y_train, R_train, X_test, Y_test, R_test):
+    model = MLPRegressor(cfg.input_dim, cfg.hidden_dim, cfg.output_dim).to(cfg.device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+
+    train_losses = []
+    test_losses = []
+
+    for epoch in range(cfg.epochs):
+        model.train()
+        epoch_loss = 0.0
+        n_batches = 0
+
+        for xb, yb, _ in iterate_sequence_minibatches(X_train, Y_train, R_train, cfg.phase_batch_size):
+            optimizer.zero_grad()
+            y_hat = model(xb)
+            loss = F.mse_loss(y_hat, yb)
+            loss.backward()
+            optimizer.step()
+
+            epoch_loss += loss.item()
+            n_batches += 1
+
+        train_losses.append(epoch_loss / max(n_batches, 1))
+        test_mse, _ = evaluate_fixed(model, X_test, Y_test, R_test)
+        test_losses.append(test_mse)
+
+        if (epoch + 1) % 25 == 0 or epoch == 0:
+            print(f"[Fixed] Epoch {epoch+1:03d}/{cfg.epochs} | Train MSE: {train_losses[-1]:.4f} | Test MSE: {test_mse:.4f}")
+
+    return model, {"train_losses": train_losses, "test_losses": test_losses}
+
+
+def train_nomadic(cfg: Config, X_train, Y_train, R_train, X_test, Y_test, R_test, phase_tags_test):
+    model = NomadicMoE(
+        input_dim=cfg.input_dim,
+        hidden_dim=cfg.hidden_dim,
+        output_dim=cfg.output_dim,
+        num_experts=cfg.num_experts,
+        gate_hidden_dim=cfg.gate_hidden_dim,
+    ).to(cfg.device)
+
+    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)
+
+    logs = {
+        "train_total_losses": [],
+        "train_mse_losses": [],
+        "train_dogma_losses": [],
+        "train_nomad_bonus": [],
+        "train_diversity_losses": [],
+        "train_sep_losses": [],
+        "train_cons_losses": [],
+        "train_mean_gate_distance": [],
+        "train_entropy": [],
+        "test_mse_static": [],
+        "test_mse_sequence": [],
+        "test_mean_gate_distance_static": [],
+        "delta_env": [],
+        "delta_err": [],
+        "delta_hybrid_raw": [],
+        "delta_hybrid": [],
+        "test_switch_latency": [],
+        "test_transition_entropy": [],
+        "test_stable_entropy": [],
+    }
+
+    for epoch in range(cfg.epochs):
+        model.train()
+
+        tracker = HybridDeltaTracker(
+            ema_decay=cfg.ema_decay,
+            err_baseline_momentum=cfg.err_baseline_momentum,
+            w_env=cfg.w_env,
+            w_err=cfg.w_err,
+            device=cfg.device,
+        )
+        tracker.reset()
+
+        epoch_total = 0.0
+        epoch_mse = 0.0
+        epoch_dogma = 0.0
+        epoch_nomad = 0.0
+        epoch_diversity = 0.0
+        epoch_sep = 0.0
+        epoch_cons = 0.0
+        epoch_entropy = 0.0
+        n_batches = 0
+
+        for xb, yb, rb in iterate_sequence_minibatches(X_train, Y_train, R_train, cfg.phase_batch_size):
+            optimizer.zero_grad()
+
+            with torch.no_grad():
+                zero_delta = torch.zeros((xb.size(0), 1), device=cfg.device)
+                warm_y, _, _, _ = model(xb, zero_delta, cfg.temperature)
+                warm_mse = F.mse_loss(warm_y, yb)
+
+            delta_hybrid, de, derr, dh = tracker.compute(xb, warm_mse)
+            y_hat, gate_probs, _, expert_outputs = model(xb, delta_hybrid, cfg.temperature)
+
+            mse_loss = F.mse_loss(y_hat, yb)
+            dogma_pen = compute_dogma_penalty(gate_probs)
+            nomad_bonus = compute_nomad_bonus(gate_probs)
+            diversity_loss = compute_diversity_loss(expert_outputs)
+
+            _, sep_loss, cons_loss, _, _ = compute_regime_gate_stats(
+                gate_probs=gate_probs,
+                regime_ids=rb,
+                num_regimes=3,
+            )
+
+            entropy_val = gate_entropy(gate_probs).mean()
+
+            total_loss = (
+                mse_loss
+                + cfg.alpha_dogma * dogma_pen
+                - cfg.beta_nomad * nomad_bonus
+                + cfg.gamma_diversity * diversity_loss
+                + cfg.lambda_sep * sep_loss
+                + cfg.lambda_cons * cons_loss
+            )
+
+            total_loss.backward()
+            optimizer.step()
+
+            epoch_total += total_loss.item()
+            epoch_mse += mse_loss.item()
+            epoch_dogma += dogma_pen.item()
+            epoch_nomad += nomad_bonus.item()
+            epoch_diversity += diversity_loss.item()
+            epoch_sep += sep_loss.item()
+            epoch_cons += cons_loss.item()
+            epoch_entropy += entropy_val.item()
+            n_batches += 1
+
+            logs["delta_env"].append(de)
+            logs["delta_err"].append(derr)
+            logs["delta_hybrid"].append(dh)
+            logs["delta_hybrid_raw"].append(tracker.delta_hybrid_raw_history[-1])
+
+        logs["train_total_losses"].append(epoch_total / max(n_batches, 1))
+        logs["train_mse_losses"].append(epoch_mse / max(n_batches, 1))
+        logs["train_dogma_losses"].append(epoch_dogma / max(n_batches, 1))
+        logs["train_nomad_bonus"].append(epoch_nomad / max(n_batches, 1))
+        logs["train_diversity_losses"].append(epoch_diversity / max(n_batches, 1))
+        logs["train_sep_losses"].append(epoch_sep / max(n_batches, 1))
+        logs["train_cons_losses"].append(epoch_cons / max(n_batches, 1))
+        logs["train_entropy"].append(epoch_entropy / max(n_batches, 1))
+
+        _, _, _, train_gate_dist_full, _, _, _, _, _ = evaluate_nomadic_static_full(
+            model, X_train, Y_train, R_train, cfg
+        )
+        logs["train_mean_gate_distance"].append(train_gate_dist_full)
+
+        test_mse_static, _, _, test_gate_dist_static, _, _, _, _, _ = evaluate_nomadic_static_full(
+            model, X_test, Y_test, R_test, cfg
+        )
+        logs["test_mse_static"].append(test_mse_static)
+        logs["test_mean_gate_distance_static"].append(test_gate_dist_static)
+
+        test_mse_sequence, _, dynamics_eval, _, _ = evaluate_nomadic_sequence_dynamics(
+            model, X_test, Y_test, R_test, phase_tags_test, cfg
+        )
+        logs["test_mse_sequence"].append(test_mse_sequence)
+        logs["test_switch_latency"].append(dynamics_eval["mean_switch_latency"])
+        logs["test_transition_entropy"].append(dynamics_eval["transition_entropy_mean"])
+        logs["test_stable_entropy"].append(dynamics_eval["stable_entropy_mean"])
+
+        if (epoch + 1) % 25 == 0 or epoch == 0:
+            print(
+                f"[Nomadic] Epoch {epoch+1:03d}/{cfg.epochs} | "
+                f"Train Total: {logs['train_total_losses'][-1]:.4f} | "
+                f"Train MSE: {logs['train_mse_losses'][-1]:.4f} | "
+                f"Train GateDist(full): {logs['train_mean_gate_distance'][-1]:.4f} | "
+                f"Train Entropy: {logs['train_entropy'][-1]:.4f} | "
+                f"Test Static MSE: {test_mse_static:.4f} | "
+                f"Test Seq MSE: {test_mse_sequence:.4f} | "
+                f"Test Static GateDist: {test_gate_dist_static:.4f} | "
+                f"Switch Latency: {dynamics_eval['mean_switch_latency']:.4f}"
+            )
+
+    return model, logs
+
+
+# ============================================================
+# Plotting
+# ============================================================
+
+def ensure_dir(path: str):
+    os.makedirs(path, exist_ok=True)
+
+
+def plot_dataset(X: torch.Tensor, R: torch.Tensor, save_path: str):
+    x = X.detach().cpu().numpy()
+    r = R.detach().cpu().numpy()
+
+    plt.figure(figsize=(7, 6))
+    for rid, name in ID_TO_REGIME.items():
+        mask = r == rid
+        plt.scatter(x[mask, 0], x[mask, 1], s=10, alpha=0.45, label=f"Regime {name}")
+
+    plt.title("Phase Dataset in Input Space")
+    plt.xlabel("x1")
+    plt.ylabel("x2")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_training_curves(fixed_logs: dict, nomadic_logs: dict, save_path: str):
+    epochs = np.arange(1, len(fixed_logs["train_losses"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, fixed_logs["test_losses"], label="Fixed Test MSE")
+    plt.plot(epochs, nomadic_logs["test_mse_static"], label="Nomadic Static Test MSE")
+    plt.plot(epochs, nomadic_logs["test_mse_sequence"], label="Nomadic Sequence Test MSE")
+    plt.xlabel("Epoch")
+    plt.ylabel("MSE")
+    plt.title("Fixed vs Nomadic Test MSE (Static vs Sequence)")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_nomadic_losses(nomadic_logs: dict, save_path: str):
+    epochs = np.arange(1, len(nomadic_logs["train_total_losses"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, nomadic_logs["train_mse_losses"], label="MSE")
+    plt.plot(epochs, nomadic_logs["train_dogma_losses"], label="Dogma")
+    plt.plot(epochs, nomadic_logs["train_nomad_bonus"], label="Nomad Bonus")
+    plt.plot(epochs, nomadic_logs["train_diversity_losses"], label="Diversity")
+    plt.plot(epochs, nomadic_logs["train_sep_losses"], label="Regime Sep")
+    plt.plot(epochs, nomadic_logs["train_cons_losses"], label="Regime Cons")
+    plt.xlabel("Epoch")
+    plt.ylabel("Value")
+    plt.title("Nomadic Loss Components")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_delta_trace(nomadic_logs: dict, save_path: str):
+    steps = np.arange(1, len(nomadic_logs["delta_env"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(steps, nomadic_logs["delta_env"], label="delta_env")
+    plt.plot(steps, nomadic_logs["delta_err"], label="delta_err")
+    plt.plot(steps, nomadic_logs["delta_hybrid_raw"], label="delta_hybrid_raw")
+    plt.plot(steps, nomadic_logs["delta_hybrid"], label="delta_hybrid_tanh")
+    plt.xlabel("Batch Step")
+    plt.ylabel("Magnitude")
+    plt.title("Hybrid Delta Trace")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_usage_bars(usage: Dict[str, np.ndarray], save_path: str, title: str):
+    regimes = ["A", "B", "C"]
+    num_experts = len(next(iter(usage.values())))
+    x = np.arange(len(regimes))
+    width = 0.22
+
+    plt.figure(figsize=(8, 5))
+    for e in range(num_experts):
+        vals = [usage[r][e] for r in regimes]
+        plt.bar(x + e * width - width, vals, width=width, label=f"Expert {e}")
+
+    plt.xticks(x, [f"Regime {r}" for r in regimes])
+    plt.ylabel("Top-1 Selection Ratio")
+    plt.title(title)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_gate_heatmap(usage: Dict[str, np.ndarray], save_path: str):
+    regimes = ["A", "B", "C"]
+    mat = np.stack([usage[r] for r in regimes], axis=0)
+
+    plt.figure(figsize=(6, 4))
+    plt.imshow(mat, aspect="auto")
+    plt.colorbar(label="Top-1 Selection Ratio")
+    plt.yticks(range(len(regimes)), [f"Regime {r}" for r in regimes])
+    plt.xticks(range(mat.shape[1]), [f"Expert {i}" for i in range(mat.shape[1])])
+    plt.title("Regime-Expert Usage Heatmap")
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_gate_distance_curve(nomadic_logs: dict, save_path: str):
+    epochs = np.arange(1, len(nomadic_logs["train_mean_gate_distance"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, nomadic_logs["train_mean_gate_distance"], label="Train Mean Gate Distance (full)")
+    plt.plot(epochs, nomadic_logs["test_mean_gate_distance_static"], label="Test Mean Gate Distance (static)")
+    plt.xlabel("Epoch")
+    plt.ylabel("Distance")
+    plt.title("Regime Mean Gate Distance")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_phase_entropy(dynamics: dict, save_path: str):
+    ent = np.array(dynamics["batch_entropies"])
+    x = np.arange(len(ent))
+
+    plt.figure(figsize=(10, 4))
+    plt.plot(x, ent, label="Batch Gate Entropy")
+    plt.xlabel("Batch Index")
+    plt.ylabel("Entropy")
+    plt.title("Gate Entropy across Phase Sequence")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_expert_trajectory(dynamics: dict, save_path: str):
+    top1 = np.array(dynamics["batch_top1"])
+    x = np.arange(len(top1))
+
+    plt.figure(figsize=(10, 4))
+    plt.plot(x, top1)
+    plt.xlabel("Batch Index")
+    plt.ylabel("Dominant Expert")
+    plt.title("Dominant Expert Trajectory across Phase Sequence")
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_dwell_histogram(dwell_times: List[int], save_path: str):
+    plt.figure(figsize=(7, 5))
+    bins = min(20, max(5, len(set(dwell_times)) if len(dwell_times) > 0 else 5))
+    plt.hist(dwell_times, bins=bins)
+    plt.xlabel("Dwell Time")
+    plt.ylabel("Count")
+    plt.title("Dwell Time Distribution")
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_switch_latency_histogram(latencies: List[int], save_path: str):
+    plt.figure(figsize=(7, 5))
+    if len(latencies) > 0:
+        bins = min(15, max(3, len(set(latencies))))
+        plt.hist(latencies, bins=bins)
+    plt.xlabel("Switch Latency")
+    plt.ylabel("Count")
+    plt.title("Switch Latency Distribution")
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_entropy_comparison(nomadic_logs: dict, save_path: str):
+    epochs = np.arange(1, len(nomadic_logs["test_transition_entropy"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, nomadic_logs["test_stable_entropy"], label="Stable Entropy")
+    plt.plot(epochs, nomadic_logs["test_transition_entropy"], label="Transition Entropy")
+    plt.xlabel("Epoch")
+    plt.ylabel("Entropy")
+    plt.title("Stable vs Transition Gate Entropy")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_switch_latency_curve(nomadic_logs: dict, save_path: str):
+    epochs = np.arange(1, len(nomadic_logs["test_switch_latency"]) + 1)
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, nomadic_logs["test_switch_latency"], label="Mean Switch Latency")
+    plt.xlabel("Epoch")
+    plt.ylabel("Latency")
+    plt.title("Epoch-wise Mean Switch Latency")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+def plot_regime_expert_alignment(dynamics: dict, save_path: str):
+    regime_map = {"A": 0, "B": 1, "C": 2}
+    regime_vals = np.array([regime_map[r] for r in dynamics["batch_regimes"]])
+    expert_vals = np.array(dynamics["batch_top1"])
+    x = np.arange(len(regime_vals))
+
+    plt.figure(figsize=(10, 5))
+    plt.plot(x, regime_vals, label="Dominant Regime")
+    plt.plot(x, expert_vals, label="Dominant Expert")
+    plt.xlabel("Batch Index")
+    plt.ylabel("Index")
+    plt.title("Regime vs Expert Alignment across Phase Sequence")
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(save_path)
+    plt.close()
+
+
+# ============================================================
+# Reporting
+# ============================================================
+
+def print_report(
+    fixed_total_mse: float,
+    fixed_per_regime: Dict[str, float],
+    nomadic_static_total_mse: float,
+    nomadic_per_regime: Dict[str, float],
+    nomadic_usage: Dict[str, np.ndarray],
+    nomadic_mean_gate_distance: float,
+    nomadic_pairwise_gate_distances: Dict[str, float],
+    seq_total_mse: float,
+    dynamics: dict,
+):
+    print("\n" + "=" * 72)
+    print("FINAL REPORT")
+    print("=" * 72)
+
+    print("\n[Fixed Model]")
+    print(f"Total Test MSE: {fixed_total_mse:.6f}")
+    for k, v in fixed_per_regime.items():
+        print(f"  Regime {k} MSE: {v:.6f}")
+
+    print("\n[Nomadic Model | Static Eval]")
+    print(f"Static Total Test MSE: {nomadic_static_total_mse:.6f}")
+    for k, v in nomadic_per_regime.items():
+        print(f"  Regime {k} MSE: {v:.6f}")
+
+    print("\n[Nomadic Model | Sequence Eval]")
+    print(f"Sequence Total Test MSE: {seq_total_mse:.6f}")
+
+    print("\n[Nomadic Regime-wise Expert Usage | Top-1 Ratio]")
+    for regime in ["A", "B", "C"]:
+        arr = nomadic_usage[regime]
+        arr_str = ", ".join([f"E{i}: {p:.3f}" for i, p in enumerate(arr)])
+        print(f"  Regime {regime} -> {arr_str}")
+
+    print("\n[Nomadic Mean Gate Distance | Static Full]")
+    print(f"Mean pairwise gate-centroid distance: {nomadic_mean_gate_distance:.6f}")
+    if len(nomadic_pairwise_gate_distances) > 0:
+        print("[Pairwise Gate Distances]")
+        for k, v in nomadic_pairwise_gate_distances.items():
+            print(f"  {k}: {v:.6f}")
+
+    print("\n[Transition Dynamics]")
+    print(f"Regime -> Expert mapping: {dynamics['regime_to_expert']}")
+    print(f"Mean switch latency: {dynamics['mean_switch_latency']:.4f}")
+    print(f"Mean dwell time: {dynamics['mean_dwell_time']:.4f}")
+    print(f"Stable-phase mean entropy: {dynamics['stable_entropy_mean']:.4f}")
+    print(f"Transition-phase mean entropy: {dynamics['transition_entropy_mean']:.4f}")
+
+    print("\nInterpretation hint:")
+    print("- Sequence Test MSE is the main performance metric in phase-transition settings.")
+    print("- Static Test MSE is only a reference check, not the main success criterion.")
+    print("- Transition entropy > stable entropy suggests gate uncertainty rises during phase shifts.")
+    print("- Shorter switch latency suggests faster nomadic response.")
+    print("- Moderate dwell time suggests neither rigid fixation nor chaotic wandering.")
+    print("=" * 72 + "\n")
+
+
+# ============================================================
+# Main
+# ============================================================
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", type=str, default="config.yaml")
+    parser.add_argument("--save_dir", type=str, default=None)
+    parser.add_argument("--device", type=str, default=None, choices=["cpu", "cuda", "auto"])
+    parser.add_argument("--seed", type=int, default=None)
+    args = parser.parse_args()
+
+    yaml_cfg = load_yaml_config(args.config)
+    cfg = build_config_from_yaml(yaml_cfg)
+
+    if args.save_dir is not None:
+        cfg.save_dir = args.save_dir
+
+    if args.seed is not None:
+        cfg.seed = args.seed
+
+    if args.device is not None:
+        cfg.device = "cuda" if (args.device == "auto" and torch.cuda.is_available()) else args.device
+
+    ensure_dir(cfg.save_dir)
+    set_seed(cfg.seed)
+
+    print(f"Using device: {cfg.device}")
+    print(f"Saving outputs to: {cfg.save_dir}")
+    print(f"Loaded config from: {args.config}")
+
+    X_train, Y_train, R_train, phase_tags_train = generate_phase_sequence(cfg, cfg.phase_train_cycles, cfg.device)
+    X_test, Y_test, R_test, phase_tags_test = generate_phase_sequence(cfg, cfg.phase_test_cycles, cfg.device)
+
+    plot_dataset(X_train, R_train, os.path.join(cfg.save_dir, "phase_dataset_input_space.png"))
+
+    fixed_model, fixed_logs = train_fixed(cfg, X_train, Y_train, R_train, X_test, Y_test, R_test)
+    nomadic_model, nomadic_logs = train_nomadic(
+        cfg, X_train, Y_train, R_train, X_test, Y_test, R_test, phase_tags_test
+    )
+
+    fixed_total_mse, fixed_per_regime = evaluate_fixed(fixed_model, X_test, Y_test, R_test)
+    (
+        nomadic_static_total_mse,
+        nomadic_per_regime,
+        nomadic_usage,
+        nomadic_mean_gate_distance,
+        nomadic_pairwise_gate_distances,
+        _,
+        _,
+        _,
+        _,
+    ) = evaluate_nomadic_static_full(
+        nomadic_model, X_test, Y_test, R_test, cfg
+    )
+
+    seq_total_mse, seq_usage, dynamics, _, _ = evaluate_nomadic_sequence_dynamics(
+        nomadic_model, X_test, Y_test, R_test, phase_tags_test, cfg
+    )
+
+    plot_training_curves(
+        fixed_logs,
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "fixed_vs_nomadic_test_mse.png"),
+    )
+    plot_nomadic_losses(
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "nomadic_loss_components.png"),
+    )
+    plot_delta_trace(
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "hybrid_delta_trace.png"),
+    )
+    plot_usage_bars(
+        nomadic_usage,
+        os.path.join(cfg.save_dir, "regime_expert_usage_bars.png"),
+        "Regime-wise Expert Usage (Top-1)",
+    )
+    plot_gate_heatmap(
+        nomadic_usage,
+        os.path.join(cfg.save_dir, "regime_expert_usage_heatmap.png"),
+    )
+    plot_gate_distance_curve(
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "regime_mean_gate_distance.png"),
+    )
+    plot_phase_entropy(
+        dynamics,
+        os.path.join(cfg.save_dir, "phase_gate_entropy.png"),
+    )
+    plot_expert_trajectory(
+        dynamics,
+        os.path.join(cfg.save_dir, "expert_trajectory.png"),
+    )
+    plot_dwell_histogram(
+        dynamics["dwell_times"],
+        os.path.join(cfg.save_dir, "dwell_time_histogram.png"),
+    )
+    plot_switch_latency_histogram(
+        dynamics["switch_latencies"],
+        os.path.join(cfg.save_dir, "switch_latency_histogram.png"),
+    )
+    plot_entropy_comparison(
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "stable_vs_transition_entropy.png"),
+    )
+    plot_switch_latency_curve(
+        nomadic_logs,
+        os.path.join(cfg.save_dir, "switch_latency_curve.png"),
+    )
+    plot_regime_expert_alignment(
+        dynamics,
+        os.path.join(cfg.save_dir, "regime_expert_alignment.png"),
+    )
+
+    print_report(
+        fixed_total_mse,
+        fixed_per_regime,
+        nomadic_static_total_mse,
+        nomadic_per_regime,
+        nomadic_usage,
+        nomadic_mean_gate_distance,
+        nomadic_pairwise_gate_distances,
+        seq_total_mse,
+        dynamics,
+    )
+
+    print("Saved files:")
+    for fname in [
+        "phase_dataset_input_space.png",
+        "fixed_vs_nomadic_test_mse.png",
+        "nomadic_loss_components.png",
+        "hybrid_delta_trace.png",
+        "regime_expert_usage_bars.png",
+        "regime_expert_usage_heatmap.png",
+        "regime_mean_gate_distance.png",
+        "phase_gate_entropy.png",
+        "expert_trajectory.png",
+        "dwell_time_histogram.png",
+        "switch_latency_histogram.png",
+        "stable_vs_transition_entropy.png",
+        "switch_latency_curve.png",
+        "regime_expert_alignment.png",
+    ]:
+        print(" -", os.path.join(cfg.save_dir, fname))
+
+
+if __name__ == "__main__":
+    main()