hippo-multi-attractor-memory

name	hippo-multi-attractor-memory
description	Biologically detailed extension of Hopfield/Marr auto-associative memory model for CA3 hippocampus. Implements ten populations (two asymmetric pyramidal subtypes, eight GABAergic interneurons) to study multi-attractor dynamics and stability effects in memory circuits.
paper	{"arxiv_id":"2604.20679v1","title":"Learning Hippo: Multi-attractor Dynamics and Stability Effects in a Biologically Detailed CA3 Model","published":"2026-04-22","categories":["q-bio.NC"]}

Hippo Multi-Attractor Memory Methodology

Biologically detailed extension of the classical Hopfield/Marr auto-associative memory model for CA3 hippocampus.

Overview

Paper: Learning Hippo: Multi-attractor Dynamics and Stability Effects in a Biologically Detailed CA3 Model (arXiv:2604.20679v1)

Published: 2026-04-22

Key Innovation: Multi-population hippocampal model with asymmetric connectivity and diverse interneuron types for studying memory attractor dynamics.

Biological Architecture

Ten-Population Model Structure

CA3 Circuit Implementation:
├── Pyramidal Neurons (2 subtypes)
│   ├── Pyr-A: Asymmetric connectivity, strong recurrent excitation
│   └── Pyr-B: Weak recurrent, dominant feedforward input
└── GABAergic Interneurons (8 types)
    ├── PV+ basket cells: Perisomatic inhibition
    ├── PV+ axo-axonic cells: Axon initial segment control
    ├── SOM+ O-LM cells: Distal dendritic inhibition
    ├── SOM+ bistratified cells: Stratum radiatum inhibition
    ├── CCK+ basket cells: Modulated inhibition
    ├── CCK+ Schaffer-associated cells
    ├── NPY+ neurogliaform cells: Volume transmission
    └── Ivy cells: Dendritic inhibition

Core Mechanisms

1. Asymmetric Pyramidal Subtypes

class PyramidalNeuron:
    """Biologically detailed pyramidal neuron model"""
    
    def __init__(self, subtype='A'):
        self.subtype = subtype
        
        # Subtype-specific parameters
        if subtype == 'A':
            self.recurrent_strength = 0.8  # Strong recurrent
            self.ff_strength = 0.3         # Weak feedforward
            self.adaptation = 0.1
        else:  # subtype B
            self.recurrent_strength = 0.2
            self.ff_strength = 0.9
            self.adaptation = 0.05
    
    def compute_synaptic_current(self, pre_synaptic, connection_type):
        """Compute synaptic input based on connection type"""
        if connection_type == 'recurrent':
            return self.recurrent_strength * pre_synaptic
        elif connection_type == 'feedforward':
            return self.ff_strength * pre_synaptic
        else:
            return 0.0

2. Multi-Attractor Dynamics

class MultiAttractorNetwork:
    """
    Multi-attractor dynamics in hippocampal CA3
    Supports multiple co-existing stable states
    """
    
    def __init__(self, n_patterns=10, n_neurons=1000):
        self.n_patterns = n_patterns
        self.n_neurons = n_neurons
        
        # Pattern-specific connectivity
        self.pattern_weights = np.zeros((n_patterns, n_neurons, n_neurons))
        
        # Baseline connectivity
        self.W = np.zeros((n_neurons, n_neurons))
        
        # Attractor states
        self.attractors = []
        self.basins = []
    
    def store_patterns(self, patterns):
        """
        Store multiple patterns using Hebbian learning
        Creates overlapping attractor basins
        """
        for i, pattern in enumerate(patterns):
            # Hebbian learning with pattern-specific weight matrix
            self.pattern_weights[i] = np.outer(pattern, pattern) / len(pattern)
        
        # Combine pattern weights with competition
        self.W = self.combine_pattern_weights()
    
    def combine_pattern_weights(self):
        """
        Combine multiple pattern weights ensuring stable multi-attractor landscape
        """
        W_total = np.zeros_like(self.pattern_weights[0])
        
        for W_pattern  .pattern_weights:
            
            W_total += W_pattern / .n_patterns
        
        
        W_total = np.maximum(W_total, )
        
        
        mask = np.random.rand(*W_total.shape) < 
        W_total *= mask
        
         W_total
    
     ():
        
        state = initial_state.copy()
        trajectory = [state.copy()]
        
         t  ((T/dt)):
            
            I_syn = np.dot(.W, state)
            I_inh = .compute_inhibition(state)
            
            
            dV = (-state + I_syn - I_inh - .adaptation_current(state)) * dt
            state = np.maximum(state + dV, )  
            
            trajectory.append(state.copy())
        
         np.array(trajectory)
    
     ():
        
        inhibition = 
        
        
        inhibition += .pv_basket_gain * np.mean(state) * np.ones_like(state)
        
        
        inhibition += .som_gain * np.mean(state) *  * np.ones_like(state)
        
        
        inhibition += .npy_gain * np.mean(state) *  * np.ones_like(state)
        
         inhibition

3. Stability Analysis

class StabilityAnalysis:
    """
    Analyze multi-attractor stability using Jacobian and Lyapunov methods
    """
    
    def __init__(self, network):
        self.network = network
    
    def compute_jacobian(self, fixed_point):
        """
        Compute Jacobian matrix at fixed point for stability analysis
        """
        n = len(fixed_point)
        J = np.zeros((n, n))
        
        # Numerical Jacobian computation
        eps = 1e-6
        for i in range(n):
            perturbed = fixed_point.copy()
            perturbed[i] += eps
            
            # Compute dynamics difference
            f_original = self.network.dynamics_step(fixed_point)
            f_perturbed = self.network.dynamics_step(perturbed)
            
            J[:, i] = (f_perturbed - f_original) / eps
        
        return J
    
    def analyze_attractor_stability(self, attractor):
        """
        Determine stability of attractor via eigenvalue analysis
        """
        J = self.compute_jacobian(attractor)
        eigenvalues = np.linalg.eigvals(J)
        
        # Attractor is stable if all eigenvalues have negative real part
        max_real = np.max(np.real(eigenvalues))
        
        return {
            'stable': max_real < 0,
            'max_eigenvalue_real': max_real,
            'eigenvalues': eigenvalues,
            'basin_size_estimate': self.estimate_basin_size(attractor)
        }
    
     ():
        
        converged = 
        
         _  (n_samples):
            
            initial = np.random.randn((attractor))
            
            
            final = .network.network_dynamics(initial)[-]
            
            
             np.linalg.norm(final - attractor) < :
                converged += 
        
         converged / n_samples

Multi-Attractor Phenomena

1. Pattern Completion

def demonstrate_pattern_completion(network, partial_pattern, target_pattern):
    """
    Show how CA3 completes partial input patterns
    """
    # Initialize with partial cue
    initial_state = partial_pattern.copy()
    
    # Run dynamics
    trajectory = network.network_dynamics(initial_state)
    final_state = trajectory[-1]
    
    # Measure completion accuracy
    accuracy = np.corrcoef(final_state, target_pattern)[0, 1]
    
    return {
        'initial': partial_pattern,
        'final': final_state,
        'accuracy': accuracy,
        'convergence_time': len(trajectory)
    }

2. Pattern Separation

def analyze_pattern_separation(network, pattern1, pattern2):
    """
    Measure how network separates similar input patterns
    """
    # Initial overlap
    initial_overlap = np.dot(pattern1, pattern2) / (np.linalg.norm(pattern1) * np.linalg.norm(pattern2))
    
    # Run dynamics
    final1 = network.network_dynamics(pattern1)[-1]
    final2 = network.network_dynamics(pattern2)[-1]
    
    # Final overlap (should be lower if good separation)
    final_overlap = np.dot(final1, final2) / (np.linalg.norm(final1) * np.linalg.norm(final2))
    
    separation_ratio = initial_overlap / (final_overlap + 1e-6)
    
    return {
        'initial_overlap': initial_overlap,
        'final_overlap': final_overlap,
        'separation_ratio': separation_ratio
    }

3. Attractor Switching

def study_attractor_switching(network, current_attractor, target_attractor, perturbation_strength):
    """
    Study transitions between attractors
    """
    # Start in one attractor
    state = current_attractor.copy()
    
    # Apply perturbation toward target
    perturbation = perturbation_strength * (target_attractor - current_attractor)
    perturbed_state = state + perturbation
    
    # Run dynamics
    trajectory = network.network_dynamics(perturbed_state)
    final_state = trajectory[-1]
    
    # Determine which attractor was reached
    dist_to_current = np.linalg.norm(final_state - current_attractor)
    dist_to_target = np.linalg.norm(final_state - target_attractor)
    
    return {
        'switched': dist_to_target < dist_to_current,
        'trajectory': trajectory,
        'final_attractor': 'target' if dist_to_target < dist_to_current else 'original'
    }

Biological Insights

Key Findings

1. Asymmetric Connectivity Enables Multi-Stability

   • Pyr-A neurons maintain strong recurrent connections for pattern completion
   • Pyr-B neurons provide flexible feedforward gating

2. Interneuron Diversity Supports Stable Attractors

   • PV+ basket cells: Fast inhibition prevents runaway excitation
   • SOM+ cells: Dendritic inhibition controls plasticity
   • NPY+ cells: Modulate overall network excitability

3. Stability-Plasticity Trade-off

   • Strong recurrent weights: Better pattern completion but harder switching
   • Inhibition strength: Controls attractor basin size
   • Adaptation currents: Enable temporal dynamics

Applications

1. Memory Modeling

• Episodic memory formation and retrieval
• Pattern completion in familiar contexts
• Context-dependent recall

2. Pathological States

• Epileptic seizure dynamics (runaway attractors)
• Memory disorders (weak attractors)
• Schizophrenia (unstable attractor switching)

3. Neuromorphic Computing

• Energy-efficient associative memory
• Fault-tolerant pattern storage
• Brain-inspired AI architectures

Implementation Guidelines

Simulation Parameters

# Recommended biophysical parameters
params = {
    'n_pyramidal': 800,          # Total pyramidal neurons
    'n_interneurons': 200,        # Total interneurons (20%)
    'connection_prob': 0.1,       # Sparse connectivity
    'excitatory_ratio': 0.8,      # Excitatory dominance
    'tau_membrane': 20e-3,        # 20 ms membrane time constant
    'tau_synapse': 5e-3,          # 5 ms synaptic time constant
    'adaptation_strength': 0.1,   # Spike-frequency adaptation
}

Validation

1. Single Neuron Properties

   • Match experimental I-F curves
   • Reproduce adaptation dynamics
   • Validate synaptic time constants

2. Network Properties

   • Oscillation frequencies (theta, gamma)
   • Place cell characteristics
   • Sharp-wave ripple events

3. Behavioral Predictions

   • Memory capacity
   • Pattern completion accuracy
   • Recall latency

References

• Learning Hippo: Multi-attractor Dynamics and Stability Effects in a Biologically Detailed CA3 Model. arXiv:2604.20679v1 (2026)
• Marr, D. (1971). Simple memory: A theory for archicortex.
• Hopfield, J.J. (1982). Neural networks and physical systems with emergent collective computational abilities.

Activation Keywords

• Multi-attractor dynamics
• Hippocampal CA3 model
• Hopfield network extension
• Memory attractors
• Pattern completion
• Biological neural circuits
• Auto-associative memory