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

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

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

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

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