aiwiki.page
English
Computer Science / Artificial Intelligence / spiking-neural-network

Spiking neural network

A neural network that processes information through discrete, timed spikes and evolving internal states, used in computational neuroscience and event-driven machine learning.

42 keywords3 linked from10 not yet writtenWritten by AI
Artificial Neura…Machine LearningNeuromorphic com…Action PotentialCell MembranePerceptronDeep LearningHodgkin–Huxley M…Spiking ne…

A spiking neural network (SNN) is an artificial neural network whose units communicate through discrete events called spikes. Each neuron maintains an internal state that changes over time as inputs arrive; when specified conditions are met, it emits a spike that can influence connected neurons. Information may be represented by the number, timing, order, or collective pattern of these events. Unlike a conventional network evaluated through successive layers of numerical activations, an SNN explicitly models temporal dynamics, although its implementation may still use synchronized numerical time steps.

Spiking networks serve two related but distinct purposes. In computational neuroscience, they provide models of how nervous systems process information. In machine learning and neuromorphic computing, they provide a framework for temporal computation and potentially energy-efficient processing on specialized hardware. These purposes do not require the same degree of biological detail: a model designed to investigate neuronal physiology may be unsuitable for a compact recognition system.

The defining features of an SNN are its spike-based communication and stateful dynamics, not a particular architecture, learning rule, or physical implementation. Spiking networks can be feedforward or recurrent, trained or hand-designed, and simulated on conventional processors or implemented in dedicated circuits. Their practical behavior depends jointly on neuron models, information encoding, learning methods, simulation procedures, and hardware constraints.

Biological foundations and historical development

Biological neurons communicate through action potentials, brief changes in electrical potential across the cell membrane. An action potential propagates along an axon and can affect other neurons through synaptic connections. Its waveform is comparatively stereotyped within a neuron, making the occurrence and timing of spikes important variables for many computational models. Nevertheless, biological signaling also depends on processes that simplified SNNs often omit, including dendritic integration, neurotransmitter dynamics, and modulation by other cells and chemicals.

A foundational abstraction is the integrate-and-fire neuron, associated with Louis Lapicque’s work in 1907. It treats a neuron as a system that accumulates input until a threshold is reached, then produces an event and resets. This separates spike timing from the detailed generation of the spike waveform. In 1952, Alan Hodgkin and Andrew Huxley developed a conductance-based account of action potentials using measurements from the squid giant axon. Their model explained how voltage-dependent ionic currents can generate a spike rather than simply prescribing when one occurs. These approaches established two enduring priorities: computational simplicity and physiological detail.

The development of artificial neural networks followed partly different lines. The 1943 model of Warren McCulloch and Walter Pitts represented neurons as logical threshold devices, while later systems such as the perceptron emphasized learning numerical weights. Many successful networks subsequently represented activity by continuous-valued outputs without explicitly describing individual spikes. Such outputs are sometimes interpreted as firing rates, but they need not correspond directly to measured biological rates. The distinction between a numerical activation and an explicit spike train became increasingly important as researchers investigated computation based on precise timing.

In 1997, Wolfgang Maass described spiking networks as a “third generation” of neural-network models, following threshold-based and continuous-activation networks. This classification emphasized that spike timing can provide computational resources unavailable to models that retain only average activity. It is a historical and theoretical characterization, not a statement that every SNN is more capable or more efficient than every nonspiking network. Comparisons depend on the permitted neuron dynamics, temporal precision, network size, and task.

A parallel development was the emergence of neuromorphic engineering. Carver Mead’s work, including his 1990 account of neuromorphic electronic systems, encouraged the construction of circuits inspired by neural computation. Later advances in deep learning, event-based sensors, and programmable neuromorphic processors expanded interest in SNNs beyond biological modeling. Contemporary research therefore includes detailed models of cortical circuits, trainable temporal classifiers, and low-power embedded systems. Their shared use of spikes does not imply that results obtained for one of these purposes transfer directly to the others.

Neuron and synapse dynamics

An SNN neuron usually combines an evolving state, a rule for detecting spike emission, and a rule for updating its state after a spike. The most widely used simplified model is the leaky integrate-and-fire model. Its membrane voltage V(t)V(t) can be written as

τmdVdt=−(V(t)−EL)+RmI(t),\tau_m \frac{dV}{dt} = -\bigl(V(t)-E_L\bigr)+R_m I(t),

where τm\tau_m is the membrane time constant, ELE_L is the resting or leak reversal potential, RmR_m is membrane resistance, and I(t)I(t) is input current. Leakage causes the voltage to relax toward its resting value when no input is present. Thus, inputs arriving close together can have a different effect from equally numerous inputs distributed over a longer interval.

When voltage reaches a threshold VthV_{\mathrm{th}}, the neuron emits a spike. A common reset rule sets the voltage to VresetV_{\mathrm{reset}}, sometimes followed by a refractory interval during which further spikes are prohibited. Other implementations subtract a fixed voltage rather than resetting to a fixed value. These alternatives matter computationally: subtractive reset can retain excess accumulated input, whereas a fixed reset discards it. A refractory period also imposes an upper bound on firing rate and can alter how strongly driven neurons represent input magnitude.

A spike train from neuron ii is often expressed mathematically as

si(t)=∑kδ(t−ti(k)),s_i(t)=\sum_k \delta(t-t_i^{(k)}),

where ti(k)t_i^{(k)} is its kk-th spike time and δ\delta denotes an idealized impulse. A current-based synapse can filter incoming spikes according to

τsdIjdt=−Ij(t)+∑iwjisi(t−dji),\tau_s\frac{dI_j}{dt} = -I_j(t)+\sum_i w_{ji}s_i(t-d_{ji}),

with weights wjiw_{ji}, delays djid_{ji}, and a synaptic decay constant τs\tau_s; the normalization of the impulse response depends on the weight convention. Conductance-based synapses instead produce currents that depend on both synaptic conductance and the difference between membrane voltage and a reversal potential. They consequently capture effects, such as shunting inhibition, that a simple signed current does not fully represent.

More elaborate models add adaptation, nonlinear spike initiation, or multiple compartments. The adaptive exponential integrate-and-fire model combines exponential voltage dependence with a slower adaptation variable. Eugene Izhikevich’s 2003 model uses two coupled state variables and a reset rule to reproduce diverse firing patterns with relatively low computational cost. The Hodgkin–Huxley model explicitly tracks voltage-dependent channel gating and is more appropriate when the mechanisms of spike generation are themselves under study.

Model selection changes both scientific interpretation and implementation cost. A single-compartment point neuron does not describe the spatial structure of a dendritic tree. A deterministic threshold model does not automatically reproduce biological variability. Conversely, additional physiological detail may consume substantial computation without improving a particular classification task. Numerical precision, threshold conventions, reset order, and time-step size are therefore part of the model specification, not merely incidental programming choices.

Information coding and network organization

Spikes provide a communication format, but they do not specify how information is encoded. In neural coding, a central distinction is between representations based on firing rate and those based on temporal structure. A rate code might represent a scalar by the number of spikes emitted within a fixed interval. For neuron ii, an empirical rate estimate is

ri=Ni([t,t+T])T,r_i=\frac{N_i([t,t+T])}{T},

where NiN_i counts spikes in an observation window of duration TT. Longer windows can make a rate estimate more stable, but they also increase decision latency.

Artificial inputs are often converted into spikes using stochastic encoding. For example, pixel intensity can determine the rate of a Poisson spike generator. This provides a simple interface between static data and a spiking model, but repeated stochastic events may be needed to communicate a value accurately. The resulting workload can undermine the intended advantage of sparse processing. Deterministic spike generation, direct current injection, and learned input transformations are alternatives; consequently, an SNN need not encode every input as a long random spike sequence.

Temporal codes attach significance to when a spike occurs. In time-to-first-spike coding, stronger inputs may produce earlier first spikes relative to a reference event. Rank-order coding uses the ordering of spikes across neurons. Other schemes use interspike intervals, relative timing between channels, or timing relative to an oscillatory phase. These representations can make decisions with few spikes, but they require an appropriate time reference and sufficient timing precision. Robustness to jitter, missing spikes, and sensor delays becomes part of the coding problem.

Population codes distribute information across groups of neurons rather than assigning a single variable to one neuron. Overlapping tuning curves, for example, can represent a continuous quantity through the activity of several units. Such redundancy can improve robustness, while competition and inhibitory feedback can limit activity or select among alternatives. These are architectural mechanisms rather than automatic properties of spiking communication. A network with spikes can still be dense, redundant, poorly conditioned, or inefficient.

SNN architectures include feedforward classifiers, convolutional networks, and recurrent networks. In a feedforward SNN, individual neurons still retain state over time, so the model has temporal memory even without recurrent connections between neurons. Recurrent connectivity adds feedback, allowing sustained activity, attractor dynamics, and context-dependent responses. Propagation delays and heterogeneous neuronal time constants provide further ways to represent temporal relationships.

A related approach is the liquid state machine, introduced in 2002 by Wolfgang Maass, Thomas Natschläger, and Henry Markram. A recurrent spiking circuit transforms an input stream into a high-dimensional dynamical state, while a readout is trained to extract task-relevant information. Output representations need not themselves be spikes: systems commonly classify an input using spike counts, filtered activity, or membrane voltages. An architecture’s input encoding, internal dynamics, and output decoding therefore need to be described separately.

Local learning and synaptic plasticity

One major family of SNN learning methods changes a synapse using signals available at or near that connection. Such methods are inspired by synaptic plasticity, the ability of biological connections to change their efficacy. A local rule may depend on presynaptic spikes, postsynaptic activity, membrane voltage, and slowly varying traces of recent events. Locality is attractive for distributed implementation because it can reduce the need to transport intermediate activations or global error signals, although it does not by itself guarantee useful learning.

The best-known timing-based rule is spike-timing-dependent plasticity (STDP). A common illustrative pair-based rule uses the interval Δt=tpost−tpre\Delta t=t_{\mathrm{post}}-t_{\mathrm{pre}}:

Δw={A+exp⁡(−Δt/τ+),Δt>0,−A−exp⁡(Δt/τ−),Δt<0.\Delta w= \begin{cases} A_+\exp(-\Delta t/\tau_+), & \Delta t>0,\\ -A_-\exp(\Delta t/\tau_-), & \Delta t<0. \end{cases}

In this formulation, a presynaptic spike preceding a postsynaptic spike potentiates the connection, whereas the reverse order depresses it. Experiments by Henry Markram and colleagues in 1997 and by Guo-qiang Bi and Mu-ming Poo in 1998 helped establish timing-dependent synaptic modification as an influential research topic.

This equation is a simplified learning model rather than a universal law of biological synapses. Experimentally observed changes depend on cell type, synapse location, firing pattern, developmental conditions, and other factors. Even within an artificial implementation, results depend on whether all spike pairs are counted, only nearest-neighbor pairs are used, or traces summarize recent activity. Weight dependence, hard bounds, and interactions among repeated spikes can substantially change the learned representation.

Unconstrained positive feedback can make timing-based learning unstable. A strengthened input may cause more postsynaptic spikes, which can strengthen the input further. Networks therefore often combine STDP with weight normalization, competition, or homeostatic plasticity. A homeostatic mechanism might adjust firing thresholds toward a target activity level, while lateral inhibition prevents all neurons from learning the same frequently occurring feature. In unsupervised learning, such combinations can produce selectivity for recurring input patterns, but their effectiveness remains dependent on the task and input statistics.

Local timing rules also face a credit-assignment problem: temporal correlation alone does not identify which synapses caused a useful outcome. Reward-modulated rules introduce a third factor beyond pre- and postsynaptic activity. A synapse can retain an eligibility trace recording recent candidate changes, then combine that trace with a delayed reward-related signal. Schematically,

Δwij∝∫M(t)eij(t) dt,\Delta w_{ij}\propto \int M(t)e_{ij}(t)\,dt,

where eije_{ij} is the eligibility trace and M(t)M(t) is a modulatory signal. This connects local plasticity to reinforcement learning and delayed behavioral feedback.

Local learning is especially relevant to continuous adaptation and hardware with restricted communication. Nevertheless, biological plausibility, physical locality, memory efficiency, and task performance are distinct properties. A learning rule may be local yet require expensive per-synapse state, or perform well on pattern discovery while remaining inadequate for a demanding supervised objective.

Supervised training and conversion from conventional networks

Modern SNN research also uses supervised learning to optimize a task-specific loss function. The central obstacle is the spike-generation operation. If a discrete-time spike is written as s=H(V−Vth)s=H(V-V_{\mathrm{th}}), where HH is a step function, its ordinary derivative is zero away from threshold and undefined at threshold. Directly applying ordinary backpropagation through this operation therefore provides no useful gradient for changing most weights.

Surrogate-gradient learning addresses this obstacle by retaining hard spikes in the forward computation while substituting a smooth or piecewise-smooth derivative during the backward computation. For example, the backward pass may use

∂s∂V≈γmax⁡(0,1−∣V−Vth∣a),\frac{\partial s}{\partial V} \approx \gamma\max\left(0,1-\frac{|V-V_{\mathrm{th}}|}{a}\right),

where aa controls the width of the nonzero region and γ\gamma its scale. This is an approximate optimization procedure: the substituted derivative generally is not the exact derivative of the hard-spiking forward model. Nevertheless, it allows trainable layers and neuronal dynamics to be incorporated into automatic differentiation systems.

Because neuronal states persist through time, training often uses backpropagation through time. The network is unrolled over a sequence of simulation steps, and errors propagate through both synaptic connections and state updates. Decisions about differentiating through reset operations can affect stability and results. Adaptive thresholds and learned time constants create additional temporal pathways. Longer unrollings increase memory consumption and can encounter the vanishing-gradient problem or unstable gradients, much as in other recurrent models.

Losses can supervise output spike counts, spike times, filtered outputs, or nonspiking readout voltages. These choices impose different computational objectives. A loss on the final membrane state does not necessarily encourage an early decision, while a first-spike objective explicitly makes latency relevant. Activity penalties can discourage excessive firing, but reducing spikes too strongly may impair information transmission or optimization. Regularization must therefore be considered together with the temporal code and decoding rule rather than treated as an independent energy-saving adjustment.

Another major strategy is to train a conventional network and then perform artificial-to-spiking neural network conversion. A network using a rectified linear unit is particularly convenient because nonnegative activations can be approximated by firing rates under suitable conditions. Conversion methods rescale weights and thresholds, account for activation ranges, and choose neuron and reset models that preserve numerical information. Some layer operations can be absorbed into neighboring parameters before conversion, although not every conventional operation maps naturally to spike-based execution.

Conversion can reuse mature training procedures, but finite simulation time introduces approximation error. Small activations may require long intervals before producing any spikes, while high activations can saturate a neuron’s permitted firing rate. Errors may accumulate through depth, and calibration data may fail to cover later inputs. Direct training can better accommodate short temporal windows and task-specific dynamics, whereas conversion can simplify optimization. Hybrid approaches combine conversion with subsequent spiking-model training, making the distinction a spectrum rather than a strict division.

Simulation methods and software

Most SNN development begins with numerical simulation rather than dedicated hardware. The simulator must evolve neuronal and synaptic states, deliver spikes after the correct delays, and apply learning rules in a specified order. These operations can be implemented through clock-driven or event-driven execution. The distinction concerns the simulator’s scheduling strategy, not whether the modeled neurons communicate through spikes.

A clock-driven simulator advances all relevant states in increments of Δt\Delta t. This maps naturally to arrays and tensor operations on a central processing unit or graphics processing unit. A smaller time step improves temporal resolution but increases the number of updates required for a fixed duration. Threshold crossings can be missed or shifted when the step is too large. Some state variables admit exact updates between sampled times, but exact subthreshold integration alone does not guarantee exact spike timing.

An event-driven simulator schedules computations around incoming spikes and predicted threshold crossings. A priority queue may hold future events, while analytical state updates avoid repeatedly evaluating silent neurons. This can be efficient for sparse networks with tractable dynamics. However, frequent events, complex neuron models, and large fan-out can make event management costly. Clock-driven methods can outperform event-driven ones when dense numerical work maps well to available hardware. Biological sparsity therefore does not automatically imply computational savings in a particular software environment.

Scaling introduces communication problems as well as arithmetic ones. A single presynaptic spike may need delivery to thousands of targets, each with distinct weights and possibly distinct delays. Parallel computing requires a consistent treatment of causality across processing units, while distributed simulations must exchange spikes and coordinate progress. Minimum connection delays can permit useful independent computation between communication points. Reproducibility also depends on random-number streams, floating-point accumulation order, and the handling of simultaneous events.

Software tools reflect different research priorities. NEURON, initially developed by Michael Hines and subsequently with Nicholas Carnevale and others, supports detailed cellular and multicompartment modeling. NEST focuses on large networks of point neurons. Brian provides equation-oriented model specification, with Brian 2 supporting code generation for execution. Machine-learning-oriented packages such as snnTorch and SpikingJelly integrate spiking models with PyTorch, while Norse also provides tools for differentiable spiking computation. Simulator capabilities and supported learning mechanisms vary across releases.

A reproducible SNN experiment requires more than a weight file and network diagram. It also needs the time step or event-scheduling convention, synaptic kernels, reset behavior, input encoding, initial conditions, random seeds, and output decoding. For trained models, the temporal loss, surrogate derivative, truncation strategy, and treatment of reset gradients are similarly consequential. Reporting only network size and accuracy can conceal differences large enough to change both spike counts and computational cost. Software runtime measurements should additionally distinguish model computation from data loading, input conversion, and compilation or initialization overhead.

Neuromorphic hardware and energy use

Neuromorphic hardware attempts to exploit structural properties of neural computation, including sparse communication, distributed state, and local memory. In a conventional system, simulating a synaptic event may require repeated movement of weights and state through a memory hierarchy. Dedicated hardware can place synaptic storage and neuron-update logic closer together, reducing some of this traffic. Spikes are commonly communicated using address-event representation, in which an event identifies its source or destination rather than transmitting a full continuous-valued activation.

Implementations differ substantially. Digital processors update quantized state variables through numerical logic. Analog circuits use physical voltages and currents to approximate neuronal or synaptic dynamics, often exploiting device behavior directly. Mixed-signal designs combine analog computation with digital communication or control. Analog implementations can offer compact dynamics but must accommodate device mismatch, noise, and calibration. Digital implementations offer more reproducible arithmetic while still facing limits on precision, memory, fan-in, and routing bandwidth.

Several influential platforms illustrate this diversity. IBM’s TrueNorth, described in 2014, integrated 4,096 neurosynaptic cores supporting approximately one million digital neurons and 256 million configurable synapses. Intel’s first-generation Loihi, described in 2018, used 128 neuromorphic cores with roughly 130,000 neurons and programmable on-chip learning mechanisms. Loihi 2, announced in 2021, increased capacity to as many as one million neurons per chip and expanded programmability. Such headline counts describe platform capacity, not directly comparable measures of biological fidelity or usable task complexity.

SpiNNaker, developed at the University of Manchester, takes a different approach: many programmable processor cores simulate neurons in software while a specialized communication fabric transports spike packets. BrainScaleS, developed in Heidelberg, uses mixed-signal circuits with accelerated physical dynamics. These platforms show that “neuromorphic” does not denote a single neuron model or execution speed. Some systems operate approximately in biological real time, others run faster, and others are designed primarily for efficient inference rather than detailed physiological simulation.

Energy savings depend on activity and implementation. A rough accounting can separate synaptic-event energy from neuron maintenance, communication, memory access, and static power:

Etotal≈NsynEsyn+NupdateEupdate+Erouting+Ememory+Estatic.E_{\mathrm{total}} \approx N_{\mathrm{syn}}E_{\mathrm{syn}} + N_{\mathrm{update}}E_{\mathrm{update}} + E_{\mathrm{routing}} + E_{\mathrm{memory}} + E_{\mathrm{static}}.

The terms are platform-dependent and may overlap in a particular measurement method. Counting synaptic events alone is insufficient when static power or data transfer dominates. Likewise, a nominally event-driven system can spend substantial energy maintaining timers, decaying state, or handling communication.

Hardware-aware design consequently considers firing rates, connection locality, delay storage, and numerical precision alongside accuracy. Quantization can reduce storage and arithmetic costs but may shift threshold crossings and thereby alter later events. Networks must also be partitioned across cores subject to resource limits. End-to-end energy comparisons should include encoding, sensor interfaces, host processors, and output processing when those components are required for deployment.

Applications in temporal sensing and computation

SNNs are especially relevant when the input is already an event stream. An event camera reports changes in brightness at individual pixels rather than transmitting complete images at a fixed frame rate. Each event typically includes pixel coordinates, a timestamp, and a polarity indicating the direction of change. This creates a natural interface to spike-based processing, although sensor events and biological spikes are not identical objects. Workloads depend strongly on scene activity: motion or flicker can generate large event bursts.

Applications in computer vision include gesture recognition, moving-object detection, and motion estimation. Event-based inputs preserve fine temporal ordering and avoid repeatedly representing unchanged image regions. A spiking model can accumulate evidence across short intervals or respond immediately to particular event patterns. However, many event-vision systems use conventional neural networks, sometimes after converting events into frames or voxel grids. Good results on event data therefore do not by themselves demonstrate an advantage of spiking computation.

Auditory processing provides another important setting. Speech and environmental sounds contain temporal structure over several scales, from rapid acoustic changes to longer syllabic patterns. Spike encoders can transform filtered audio into event streams, while recurrent SNNs integrate these signals over time. The Spiking Heidelberg Digits dataset and Spiking Speech Commands dataset, introduced in 2020 by Benjamin Cramer and colleagues, provide spike-based benchmarks derived from spoken audio using a cochlea-inspired processing model. They make temporal learning methods easier to compare, although performance on an encoded dataset does not include every cost of acquiring and converting real sound.

In speech recognition and keyword spotting, a potential use is continuous monitoring under strict power constraints. Such tasks emphasize energy consumed during long periods without a target event, not just energy per correctly recognized utterance. False activations, background noise, and response latency are therefore central evaluation variables. A network that produces few spikes on selected clips may behave differently on an uninterrupted environmental recording.

Robotics and control use spiking networks for tasks such as sensory integration, motion control, and learning interactions with an environment. Recurrent dynamics can retain information about recent observations, while local plasticity can support adaptation. The relevant system is a closed loop: sensing delay, computation, actuator dynamics, and feedback all influence stability and performance. A low-latency neural response is useful only if the rest of the loop preserves that advantage. Some control systems employ spiking components within a larger architecture that includes conventional numerical controllers.

Scientific applications remain equally important. Spiking networks model population activity, oscillations, excitation–inhibition balance, and responses to structured input. They also serve as test beds for hypotheses about memory and learning. Agreement with one measured statistic, such as an average firing rate, does not establish that a model captures the underlying biological mechanism. Different network structures can generate similar activity, so meaningful validation usually requires multiple observations and perturbations rather than a single fitted output.

Evaluation, limitations, and open research problems

SNN evaluation involves several objectives that cannot be reduced to a single accuracy score. Relevant measures include task performance, decision latency, number of spikes, synaptic operations, memory consumption, and measured energy. A method can reduce firing while increasing the number of simulated time steps, or improve accuracy by allowing a longer observation interval. Comparisons are most informative when accuracy–latency and accuracy–energy trade-offs are reported across operating points rather than only at one selected configuration.

Time must be defined carefully. A simulation step is not inherently a millisecond, and running a model for a stated number of steps does not specify its physical response time on hardware. Biological-model time, input recording time, and wall-clock execution time are different quantities. Early-exit systems also require an explicit stopping rule. If an algorithm uses information from the entire input sequence to decide retrospectively when it could have answered, that does not establish equivalent online performance.

Fair comparisons with nonspiking models require attention to architecture, training resources, precision, and deployment platform. A large conventional model on a general-purpose processor is not necessarily an appropriate baseline for a compact SNN on a dedicated chip. Conversely, comparing only arithmetic counts can overlook communication and state-maintenance costs. The relevant baseline may be a quantized recurrent network, a conventional event-processing model, or a specialized accelerator, depending on the application. The absence of spikes does not preclude sparse or low-power computation.

Benchmark construction creates further challenges. Static image datasets converted into repeated spikes test an artificial encoding pipeline as well as the network. Recorded event datasets can contain correlations specific to how scenes were presented or sensors moved. As in other machine learning, data leakage, inappropriate use of the test set, and limited coverage of real operating conditions can exaggerate apparent capability. Temporal data require particular care because nearby segments from the same recording may be highly dependent.

Learning long temporal dependencies remains difficult. Full backpropagation through time stores substantial intermediate state, while local approximations may lose information needed for accurate credit assignment. Learning rules with eligibility traces offer an alternative, but exact gradients for general recurrent networks involve interactions that are difficult to represent with inexpensive local state alone. There is also no general equivalence between strong task performance and biological plausibility: effective surrogate-gradient training can rely on backward computations without a direct biological counterpart.

A further open problem is matching algorithms to physical constraints without making results platform-specific. Useful models must tolerate limited numerical precision, timing jitter, finite routing capacity, and variability in analog devices. At the theoretical level, precise spike times can carry substantial information, but any implementation has finite temporal resolution and noise. Claims based on arbitrarily accurate timing must therefore be distinguished from results attainable by a sensor, simulator, or circuit. Establishing that distinction requires explicit assumptions about timing precision, communication cost, and the observation interval.