Spike Storms: Certified Worst-Case Energy Budgets for Spiking Neural Networks

Spiking neural networks (SNNs) are attractive because they replace expensive multiply-accumulate arithmetic with cheap, event-driven accumulation: a neuron does work only when it "fires," so power draw tracks the number of spikes rather than the size of the network. This is the basis for reported gains like a 5.1× arithmetic energy reduction ($0.9$ pJ per accumulate versus $4.6$ pJ per multiply-accumulate in 45nm CMOS, per SpikingBERT) and a 75× end-to-end energy reduction on Intel Loihi for robot navigation (Tang et al.). But these are average-case numbers measured on benign workloads. The same event-driven property that saves energy on quiet inputs makes the hardware's worst case adversarially interesting: an input that drives neurons into sustained high-frequency firing — a "spike storm" — can erase the efficiency advantage entirely, much as an adversarial input erases a classifier's accuracy. Energy on neuromorphic hardware is proportional to spikes processed (Tavanaei et al., Jang et al.), so worst-case spike count is worst-case energy.

We propose treating this as a program-analysis problem and building the first combined static and dynamic analyzer for SNN energy. The static pass soundly over-approximates the temporal dynamics of leaky integrate-and-fire (LIF) neurons — where an internal membrane potential accumulates input current, decays over time, and discontinuously resets when it crosses a firing threshold — to certify an upper bound on synaptic events over a whole input region. The dynamic pass searches for concrete spike-storm witnesses, with the static analysis steering the search and the witnesses tightening the bound. This mirrors the hybrid loop that proved decisive in software testing, where SAVIOR steered concolic execution with static "bug labels" and ConSym used concrete execution to eliminate 96% of static false positives. Nobody has applied that loop to the energy behavior of spiking hardware: the closest works are empirical spike-retiming attacks, which find witnesses but certify nothing, and abstract-interpretation tools for dense networks, which cannot handle stateful spiking dynamics at all.

Core Claim

The central claim is twofold. First, worst-case spike storms in deployed SNNs are a real, measurable gap: concrete inputs within small perturbation radii of ordinary test data can inflate synaptic-event counts by large factors over typical operating points. Second, this gap can be certified bounded: by extending abstract interpretation — the classic static technique of over-approximating all possible program states with tractable mathematical objects — to LIF state, we can prove that no input in a specified region exceeds a stated spike budget, and the dynamic search tells us how tight that budget is.

Formally, for an SNN with LIF neurons whose membrane potential follows $V_{t+1} = \lambda V_t + \sum_i w_i s^t_i$ (where $\lambda$ is the leak/decay factor, $w_i$ are synaptic weights, and $s^t_i \in \{0,1\}$ are incoming spikes), which emits a spike and resets when $V_t \geq V_{th}$, we define the energy proxy $E(x) = \sum_{t \leq T} \sum_{(i,j)} s^t_i w_{ij}$-triggered synaptic events for input $x$. The analysis takes an input region $X$ (an $L_\infty$ ball around a test input, as in robustness certification) and produces either a proof that $E(X) \leq B$ or a concrete $x' \in X$ with $E(x') > B$. The quantitative expectation is that the certified bound $B$ will sit far below the vacuous ceiling of every-neuron-fires-every-timestep, because decay and threshold arithmetic constrain how fast potentials can rebuild after a reset; where the form comes from is the leak term $\lambda < 1$ bounding charge accumulation between resets.

Research Program

Three components are built, in the hybrid pattern the software-testing literature has validated. The static pass is an abstract interpreter for LIF dynamics. AI² demonstrated that box and zonotope domains can certify robustness of stateless ReLU networks up to 53,000 neurons in under 10 seconds, but it explicitly cannot represent state that persists, leaks, and discontinuously resets across timesteps. We extend it by carrying a membrane-potential abstract value per neuron per timestep, treating threshold-crossing like AI² treats ReLU branching (a split into spike/no-spike cases, joined by convex hull) and treating the reset as a stateful update. The design borrows from Abstract Interpretation of Stateful Networks, which made stateful middlebox verification tractable by abstracting packet order and per-middlebox state — we adapt its order abstraction into a timestep abstraction, since consecutive-timestep precision is what the domain must give up to stay tractable over the temporal window $T$. The key soundness wrinkle is that unlike ReLU, a spike both consumes state (reset) and produces downstream input, so the interpreter must propagate abstract spike sets forward through synaptic weights, accumulating a certified event count.

The dynamic pass searches for witnesses that maximize $E$. Following NEUZZ, which trained a smooth neural surrogate of a program's branching behavior and followed its gradients to reach untaken branches (3× edge coverage over ten graybox fuzzers), we train a differentiable surrogate of the SNN's firing behavior and follow input gradients uphill on predicted spike count. Here the known tension must be confronted head-on: NEUZZ's premise is that smoothing is needed because program behavior is discontinuous, while SNNs are discontinuous by construction, and their training already requires surrogate-gradient tricks (Zheng et al. normalized activations to the firing threshold to stabilize direct training; SpikingBERT differentiated implicitly at dynamical equilibrium). We reuse those surrogate-gradient constructions, but pointed at energy rather than accuracy. The static pass steers this search in SAVIOR's manner: neurons whose abstract interval straddles the threshold — statically ambiguous firing sites — become the "bug labels," and inputs are prioritized by the density of reachable ambiguous sites they touch, rather than by raw coverage.

The feedback loop closes the circle in the ConSym pattern. Where the static pass proves a low bound for some subregion, the dynamic search skips it; where the static pass flags a potential storm but dynamic exploration of the concretely reachable state space shows the flagged potentials cannot actually be reached under real input constraints, the flag is refined away — directly analogous to how ConSym used concrete execution of smart-contract constructors to impose realistic initial states and cut static false positives by 96%. All energy figures are reported in synaptic-event counts converted through the published 45nm CMOS accumulate cost of $0.9$ pJ (SpikingBERT); we deliberately do not claim measured joules on physical neuromorphic silicon, since none of the cited training pipelines ran on it and the file records no Loihi/TrueNorth facility available to us — event counts are the hardware-independent currency.

Baselines

The naive reference point is the typical operating point: the mean and 99th-percentile synaptic-event count per inference, measured by simply running each SNN on its own test set with no adversary and no analysis. Every energy-efficiency claim in the file is stated against this reference (for example, 44.5 mW active processing on TrueNorth for gesture recognition at 96.49% accuracy, Amir et al.), so it is the number a deployment engineer currently relies on. Beating it means showing concrete witnesses whose event counts exceed the 99th-percentile typical by a large factor, and certifying a bound that is nonetheless far below the vacuous ceiling — the gap between witness and certificate quantifies residual risk.

The strongest existing competitor is the empirical spike-retiming attack on event-driven SNNs (Time Is All It Takes: Spike-Retiming Attacks on Event-Driven Spiking Neural Networks), the only prior method in the file that deliberately manipulates SNN spike behavior adversarially. It is the strongest because it is purpose-built for exactly our threat model — an adversary perturbing event streams to degrade an SNN — whereas robustness tools like AI² do not apply to stateful spiking dynamics at all. We will reimplement its retiming perturbation on our models and run it with the same iteration budget, the same perturbation radii, and the same compute as our gradient-guided dynamic search, so the comparison isolates guidance quality rather than effort. No reported result found on Lacuna for the spike-retiming attack's energy inflation or accuracy degradation, so establishing that number is itself a contribution. We count ourselves as beating it only if our statically guided search finds witnesses with strictly higher event counts under matched budgets, and produces a certified bound — something an attack cannot do by construction, per the certification-versus-counterexample argument AI² makes: pointwise attacks cannot cover the infinite input neighborhood.

Two ablations isolate the proposal's key ingredients. A static-only ablation runs the abstract interpreter with no dynamic refinement, measuring how badly it over-approximates; we expect it to storm-flag many regions that are unreachable in practice, echoing the pattern ConSym documented for static analyzers drowning in false alarms. A dynamic-only ablation runs the surrogate-gradient search with static labels removed and pure coverage-based scheduling restored, predicting the wasted-effort failure SAVIOR demonstrated for coverage-driven exploration (it beat the concolic fuzzer QSYM by 44.3% in bug-finding speed precisely by prioritizing danger sites over edges). Finally, the trivial per-neuron ceiling — every neuron fires every timestep, i.e., $N \times T$ spikes times fan-out — is computed as a sanity anchor: every certified bound must sit strictly below it or the machinery is adding nothing.

Why not just…?

Why not just run empirical attacks and skip the static analyzer? This is the most serious alternative, and we treat it as such. Spike-retiming attacks (Time Is All It Takes) can plausibly find dramatic spike storms on their own, and gradient-guided maximization may too. What they cannot produce is a deployment-grade statement of the form "no input within radius $\varepsilon$ exceeds budget $B$" — the same limitation AI² identified for empirical adversarial testing of dense networks, where the continuous neighborhood contains infinitely many of what pointwise testing samples finitely. The honest resolution is that the experiments must show the certificate is tight enough to matter: if the certified bound always lands orders of magnitude above what attacks find, the static pass is decoration, and we would report that. The decisive check is the witnessed-versus-certified ratio per benchmark.

Why not just apply AI² or AMDL off the shelf? Neither works as-is, and the file is explicit about why. AI² is restricted to stateless feed-forward networks with piecewise-linear activations; LIF neurons carry decaying state across timesteps and reset discontinuously, which its domains cannot express. Abstract Interpretation of Stateful Networks handles persistent state, but for discrete packet-processing middleboxes with packet-effect semantics, not continuous membrane decay and threshold arithmetic. Our contribution is precisely the domain construction that bridges them; the risk is that the per-timestep state explosion makes it too slow — which is why the scalability experiment against AI²'s sub-10-second, 53,000-neuron runtime is a headline metric rather than an afterthought.

Why not just use the trivial firing-rate ceiling ($N \times T$)? A skeptic will correctly note that LIF neurons physically cannot fire more than once per timestep, so worst-case energy is trivially bounded by network size times timesteps times fan-out. This bound is sound, free, and — we claim — useless, because it scales with the whole network rather than the input region: on the models in the file, e.g., a directly trained spiking ResNet running ImageNet in 6 timesteps (Zheng et al., 67.05% top-1), the ceiling would be astronomically above the typical operating point, and the entire economic case for neuromorphic deployment rests on typical sparsity (Amir et al., Tang et al.). Our analyzer's value is per-input-region tightness. But we commit to the falsifiable comparison: if on every benchmark our certified bound is within a small constant of the trivial ceiling, the simple alternative wins and the paper says so.

Why not just make the SNNs robust by training? Regularizing firing rates or adversarial training against spike storms is a plausible mitigation, but it presupposes both a threat model and an evaluation oracle — which is exactly what this proposal supplies. Moreover, training-based defenses are empirical and can be broken by stronger attacks, as robustness research on dense networks repeatedly showed; a certified budget composes with any subsequently trained model. We position training-based defense as downstream consumer of our analyzer, not a competitor.

Proposed Experiments

Experiments run on four models drawn from the file's benchmark set, spanning the SNN design space: the STBP-tdBN directly trained spiking ResNet, which reached 96.87% on DVS-Gesture, 93.16% on CIFAR-10, and 67.05% ImageNet top-1 in 6 timesteps (Zheng et al.); and the spiking language model of SpikingBERT (88.19% on SST-2), which adds attention-driven temporal dynamics. DVS-Gesture is the primary benchmark because it is natively event-based and has a directly comparable hardware-energy reference point: TrueNorth running it at 178.8 mW total / 44.5 mW active at 96.49% accuracy (Amir et al.), letting us translate certified event counts into a defensible millijoule figure via the 0.9 pJ accumulate model.

Four measurements decide the proposal. First, the storm gap: the ratio of the best concrete witness's synaptic-event count to the 99th-percentile typical count, across perturbation radii, for our guided search, the reimplemented spike-retiming attack, and unguided gradient ascent. Second, certificate tightness: the ratio of the certified bound to the best witness, per radius; ratios near 1 mean the analyzer both finds and proves. Third, scalability: abstract-interpreter wall-clock versus network size and timestep count $T$, benchmarked against AI²'s reported certification of networks up to 53,000 neurons in under 10 seconds, with the expectation that timestep unrolling costs a roughly $T$-fold slowdown — a cost the timestep abstraction is designed to blunt. Fourth, the hybrid loop's contribution: static-only false-storm rate (predicting ConSym-like over-alarm), dynamic-only witness yield under matched budget, and full-pipeline yield, mirroring the SAVIOR-style comparison in which guidance beat unguided engines by 43–44% in discovery speed. The decisive checks are simple: a certified bound strictly below the trivial ceiling while concrete witnesses exceed typical operation by a large factor, at a runtime a verification engineer would actually pay.