memristive-spiking-dynamics-resonance - SKILL.md Agent Skill

name: memristive-spiking-dynamics-resonance description: Modeling intrinsic neuro-synaptic spiking dynamics and resonance in self-organizing memristive networks. Demonstrates how physical circuits naturally generate neuronal population dynamics similar to biological systems. version: 1.0.0 author: Research Synthesis license: MIT metadata: hermes: tags: [memristive-networks, spiking-dynamics, resonance, neuromorphic, self-organizing, neuro-synaptic] source_paper: "Intrinsic Neuro-Synaptic Spiking Dynamics and Resonance in Memristive Networks (arXiv:2604.18015)" authors: "Yinhao Xu, Georg A. Gottwald, Zdenka Kuncic" published: "2026-04-20"

Intrinsic Neuro-Synaptic Spiking Dynamics in Memristive Networks

Overview

Self-organizing memristive networks are physical circuits that dynamically reconfigure their circuitry in response to external input signals. This methodology demonstrates that such networks naturally generate neuronal population spiking dynamics similar to biological neuronal systems, with optimal computation occurring at the maximal frequency before resonance onset.

Core Concepts

Memristive Network Dynamics

Memristive networks combine:

Intrinsic neuro-synaptic dynamics: Individual memristor behavior mimics synaptic plasticity
Heterogeneous network topology: Complex connectivity patterns enable emergent dynamics
Self-organization: Dynamic circuit reconfiguration in response to inputs

Resonance Phenomenon

Nonlinear spike-like features are maximized when input frequency matches the network's intrinsic dynamical timescale. The optimal computation frequency is the maximal frequency before resonance onset.

import numpy as np

def analyze_resonance(frequencies, network_response_func):
    """
    Analyze nonlinear resonance in memristive networks.
    
    Returns:
        resonance_freq: Frequency with maximum spike features
        optimal_freq: Best computation frequency (before resonance)
    """
    response_amplitude = []
    
    for freq in frequencies:
        response = network_response_func(freq)
        
        # Detect spike-like features
        spikes = detect_spikes(response)
        amplitude = np.sum(np.abs(spikes))
        response_amplitude.append(amplitude)
    
    response_amplitude = np.array(response_amplitude)
    
    # Find resonance frequency
    resonance_idx = np.argmax(response_amplitude)
    resonance_freq = frequencies[resonance_idx]
    
    # Optimal computation frequency (before resonance onset)
    if resonance_idx > 0:
        optimal_freq = frequencies[resonance_idx - 1]
    else:
        optimal_freq = frequencies[0]
    
    return resonance_freq, optimal_freq, response_amplitude

def detect_spikes(signal, threshold=2.0):
    """Detect spike-like features in time series."""
    mean = np.mean(signal)
    std = np.std(signal)
    
    spikes = signal.copy()
    spikes[np.abs(spikes - mean) < threshold * std] = 0
    
    return spikes

Mathematical Framework

class MemristiveNetwork:
    """
    Self-organizing memristive network model.
    """
    
    def __init__(self, n_nodes, topology='heterogeneous'):
        self.n_nodes = n_nodes
        self.topology = topology
        # Initialize memristances (resistance values)
        self.memristances = np.random.uniform(1e3, 1e6, size=(n_nodes, n_nodes))
        # R_min and R_max bounds
        self.R_min = 100
        self.R_max = 1e7
        
    def update_memristance(self, voltage, current, dt, k=1e-3):
        """
        Update memristance based on voltage-current relationship.
        Follows the memristor state equation: dM/dt = -k * V * I * window
        """
        # Window function for boundary effects
        window = self._boundary_window(self.memristances)
        
        # State-dependent dynamics
        dM = -k * voltage * current * window
        self.memristances += dM * dt
        
        # Apply physical bounds
        self.memristances = np.clip(self.memristances, self.R_min, self.R_max)
        
    def _boundary_window(self, M):
        """
        Window function that slows changes near resistance bounds.
        """
        x = (M - self.R_min) / (self.R_max - self.R_min)
        return x * (1 - x)
    
    def simulate(self, input_signal, duration, dt=1e-6):
        """
        Simulate network response to input signal.
        """
        t_steps = int(duration / dt)
        responses = []
        
        for i in range(t_steps):
            V_input = input_signal(i * dt)
            
            # Solve circuit equations (Ohm's law with memristive elements)
            I_response = self._solve_circuit(V_input)
            
            # Update memristances
            self.update_memristance(V_input, I_response, dt)
            
            responses.append(I_response)
        
        return np.array(responses)
    
    def _solve_circuit(self, V_input):
        """
        Solve circuit equations for current response.
        Uses Kirchhoff's laws with memristive elements.
        """
        # Simplified: I = V / R_effective
        R_effective = np.mean(self.memristances)
        return V_input / R_effective

Key Findings

Biological-like Dynamics: Memristive networks naturally generate spiking dynamics similar to biological neuronal systems
Nonlinear Resonance: Spike-like features maximized when input frequency matches intrinsic dynamical timescale
Optimal Computation: Occurs at maximal frequency before resonance onset
Self-Organization: Networks dynamically reconfigure circuitry in response to inputs

Applications

Neuromorphic computing hardware design
Bio-inspired circuit development
Understanding biological neural dynamics through physical analogs
Energy-efficient neural network implementations

References

Intrinsic Neuro-Synaptic Spiking Dynamics and Resonance in Memristive Networks
Authors: Yinhao Xu, Georg A. Gottwald, Zdenka Kuncic
arXiv: 2604.18015
Published: 2026-04-20
Categories: cond-mat.dis-nn, cs.ET

Related Skills

[[spiking-neural-network-analysis]]
[[neuromorphic-spiking-ring-attractor-v2]]
[[circuit-level-spiking-neuron-robustness]]