self-sustained-neuron-population

name: self-sustained-neuron-population description: "Modeling self-sustained neural activity in recurrent networks without external input. Hodgkin-Huxley neurons with STDP and stochasticity maintain autonomous sparse firing for 1800+ seconds after brief initialization. Use when studying autonomous brain dynamics, self-sustained activity, spontaneous neural reorganization, or biologically plausible network simulation." version: 1.0.0 metadata: hermes: source_paper: "Modeling of Self-sustained Neuron Population without External Stimulus (arXiv:2604.13719)" tags: [neuroscience, self-sustained, hodgkin-huxley, stdp, autonomous-activity]

Self-Sustained Neuron Population Modeling

Overview

Self-sustained neural activity in the absence of ongoing external input is a fundamental feature of nervous system dynamics. Recurrent Hodgkin-Huxley networks with plastic and stochastic synapses sustain long-duration autonomous activity in a sparse firing regime after brief (200ms) initialization.

Core Mechanism

A recurrent network of 200 neurons (160 excitatory, 40 inhibitory) with 80% connection probability maintains autonomous activity through:

• Excitatory and inhibitory STDP
• Probabilistic vesicle release
• Probabilistic synapse formation
• Receptor variability
• Voltage-dependent inhibition

Key Results

Implementation Pattern

import numpy as np

class SelfSustainedNetwork:
    """Recurrent HH network with STDP maintaining autonomous activity."""
    
    def __init__(self, n_excitatory=160, n_inhibitory=40, conn_prob=0.8):
        self.n_total = n_excitatory + n_inhibitory
        self.n_exc = n_excitatory
        self.n_inh = n_inhibitory
        self.conn_prob = conn_prob
        
        # Initialize connectivity
        self.weights = self._init_connectivity()
        
    def _init_connectivity(self):
        """Probabilistic synapse formation."""
        W = np.zeros((self.n_total, self.n_total))
        mask = np.random.random(W.shape) < self.conn_prob
        W[mask] = np.random.normal(0, 1, size=mask.sum())
        return W
    
    def apply_stdp(self, pre_spike, post_spike):
        """Excitatory and inhibitory STDP rules."""
        # Asymmetric STDP window
        pass
    
    def initialize(self, duration_ms=200, target_neurons=30):
        """Brief transient stimulation to subset of excitatory neurons."""
        pass
    
    def run_autonomous(self, duration_s=1800):
        """Run without any external input."""
        # Monitor sparse, irregular activity
        # Track Fano factors, participation rates
        pass

# Usage: initialize then run autonomous
net = SelfSustainedNetwork()
net.initialize(duration_ms=200, target_neurons=30)
activity = net.run_autonomous(duration_s=1800)
# Network maintains sparse firing without external drive

Applications

• Autonomous brain dynamics modeling: Study self-sustained cortical activity
• Spontaneous reorganization: Track qualitative changes in collective firing patterns
• Neuromorphic systems: Low-power always-on neural computation
• Epilepsy research: Understand transition between sparse and synchronized states

References

• Original paper: arXiv:2604.13719v1
• Authors: Karakaş, Özel, Ulusoy, Koçak
• Published: 2026-04-15