heteroclinic-cognitive-state-modeling

---
name: heteroclinic-cognitive-state-modeling
description: "Modeling sequential cognitive states via population-level cortical dynamics using Universal Approximation Theorem to approximate heteroclinic cycles with neural field systems. Activation: heteroclinic cognitive states, sequential brain dynamics, Lotka-Volterra neural model, Amari neural field approximation, meditation state transitions."
---

# Heteroclinic Cognitive State Modeling via Neural Field Approximation

> Uses the Universal Approximation Theorem to approximate heteroclinic cycle dynamics with high-dimensional Amari-type neural-field systems, enabling modeling of sequential cognitive state transitions.

## Metadata
- **Source**: arXiv:2605.02365
- **Authors**: M Virginia Bolelli, Luca Greco, Dario Prandi
- **Published**: 2026-05-04
- **Category**: math.DS, q-bio.NC

## Core Methodology

### Key Innovation
This paper establishes a **bridge between abstract dynamical systems and biologically interpretable neural models**:

1. **Impossibility result**: Spatial-discrete neural-field equations with biologically realistic equilibria **cannot** support heteroclinic cycles
2. **Lotka-Volterra gap**: Heteroclinic dynamics arise naturally in Lotka-Volterra systems, but these don't directly correspond to neuronal processes
3. **UAT solution**: Use the Universal Approximation Theorem to approximate **any** target dynamics (including heteroclinic cycles) by a neural network interpretable as a high-dimensional Amari-type neural-field system
4. **Approximation guarantee**: When the target dynamics contains a heteroclinic cycle, the approximating vector field generates a **periodic trajectory that closely follows the heteroclinic connection**

### Technical Framework

**The impossibility theorem:**
- Discrete neural-field equations with biologically realistic equilibria (bounded firing rates, sigmoidal activation) cannot generate the saddle-point structure required for heteroclinic cycles
- This is a fundamental limitation of direct neural-field modeling

**The approximation approach:**
```
Target dynamics (Lotka-Volterra with heteroclinic cycle)
         ↓
Universal Approximation Theorem
         ↓
Neural network → Interpreted as Amari-type neural-field system
         ↓
Periodic trajectory ≈ Heteroclinic connection
```

**Amari-type neural-field form:**
```
τ du_i/dt = -u_i + Σ_j w_ij · σ(u_j) + I_i
```
where:
- u_i: activity of neural population i
- w_ij: connectivity weights (learned via UAT approximation)
- σ: sigmoidal activation function
- I_i: external input

### Implementation Guide

**Step 1: Define target heteroclinic dynamics**
```python
import numpy as np

def lotka_volterra_heteroclinic(x, params):
    """Lotka-Volterra system with heteroclinic cycle between K fixed points."""
    n = len(x)
    dx = np.zeros(n)
    for i in range(n):
        dx[i] = x[i] * (1 - x[i] - params['alpha'] * sum(
            params['beta'][i, j] * x[j] for j in range(n) if j != i
        ))
    return dx
```

**Step 2: Approximate with neural network**
```python
import torch
import torch.nn as nn

class AmariNeuralField(nn.Module):
    """Amari-type neural field approximating target dynamics."""
    
    def __init__(self, n_units):
        super().__init__()
        self.W = nn.Parameter(torch.randn(n_units, n_units) * 0.1)
        self.bias = nn.Parameter(torch.zeros(n_units))
        self.tau = nn.Parameter(torch.ones(n_units))
        
    def forward(self, u):
        """du/dt = (-u + W·σ(u) + bias) / tau"""
        sigma_u = torch.sigmoid(u)
        du = (-u + self.W @ sigma_u + self.bias) / self.tau
        return du
    
    def step(self, u, dt=0.01):
        """Euler integration step."""
        du = self.forward(u)
        return u + dt * du
```

**Step 3: Train via dynamics matching**
```python
def train_dynamics_matching(model, target_fn, n_steps=10000, lr=1e-3):
    """Train neural field to approximate target dynamics."""
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    
    for _ in range(n_steps):
        # Sample points in state space
        u = torch.randn(model.W.shape[0])
        
        # Target and predicted dynamics
        target_du = torch.tensor(target_fn(u.detach().numpy()))
        predicted_du = model(u)
        
        # Match vector fields
        loss = torch.mean((predicted_du - target_du) ** 2)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    return model
```

**Step 4: Verify heteroclinic behavior**
```python
def verify_heteroclinic_approximation(model, initial_state, n_steps=5000):
    """Verify that the trained model produces heteroclinic-like trajectories."""
    trajectory = [initial_state]
    u = initial_state
    
    for _ in range(n_steps):
        u = model.step(u, dt=0.01)
        trajectory.append(u.detach().clone())
    
    trajectory = torch.stack(trajectory)
    
    # Check for sequential state transitions
    # Each "state" corresponds to a different population being active
    state_sequence = torch.argmax(trajectory, dim=1)
    
    # Verify cycling through states
    unique_states = torch.unique(state_sequence)
    return trajectory, state_sequence, unique_states
```

## Applications
- **Sequential cognitive processes**: Modeling ordered transitions between mental states
- **Focused-attention meditation**: Reproducing attention → distraction → refocus cycles
- **Task switching**: Modeling transitions between different cognitive task sets
- **Working memory updating**: Sequential encoding and retrieval operations
- **Decision-making dynamics**: Sequential evidence accumulation and state transitions

## Pitfalls
- **Approximation quality**: The UAT guarantee is existential; practical approximation quality depends on network size and training
- **Biological interpretability**: The learned weights may not correspond to meaningful biological connectivity
- **Stability**: Approximated heteroclinic cycles are actually periodic orbits; stability properties differ from true heteroclinic connections
- **Time scale separation**: True heteroclinic dynamics often require separation of time scales; the approximation may not preserve this
- **Dimensionality**: High-dimensional neural fields are needed for good approximation, increasing computational cost

## Related Skills
- heteroclinic-neural-field-cognition
- neural-dynamics-decision-making
- attractor-metadynamics-neural
- neural-population-dynamics
- tsodyks-markram-chaotic-dynamics