Spikes as the Stopping Rule: Exact Event-Driven Local Updates for Streaming Graphs

Many real graphs never stop changing. Users message each other, people edit pages, buyers click on products. Models that learn on these graphs face a choice. They can recompute everything at fixed intervals, which wastes work on the parts of the graph that did not change. Or they can update only a neighborhood around each new edge, which raises two questions that are hard to answer in general: how far the update should spread, and how much error builds up when it stops early. Spiking neural networks are networks whose neurons stay silent until an internal charge crosses a threshold, and then send a single binary pulse. They have a property that answers both questions. When a new edge arrives, the change spreads to a neighbor only if it pushes some neuron across its threshold. Everything below threshold stays inside the neuron's stored charge and causes no downstream computation.

We propose a streaming spiking graph network that processes each edge as it arrives. The set of nodes it touches per event is decided by which neurons actually fire, not by a fixed k-hop radius. If the network contains no constant bias currents and applies its charge decay lazily, only when a node is read, then this local update is mathematically identical to simulating the whole graph. Long-run drift, the standing weakness of localized graph updates, then disappears by construction. The open question becomes whether a spiking model is accurate enough on hard streaming benchmarks. The energy argument also has a concrete form: per-event cost should scale with the number of spikes the event causes, using additions only, rather than with the size of the neighborhood.

Core Claim

All existing dynamic spiking graph models run the whole graph at each step of a discrete sequence of snapshots: SpikeNet, Dy-SIGN, Delay-DSGN, and ChronoSpike. ChronoSpike says outright that continuous-time event streams are future work. Each of these models collects edges into time windows and runs message passing over the full snapshot. This wastes the one property that makes spiking hardware efficient, namely that power tracks activity (Tavanaei et al.).

The models that do update locally use dense floating-point units and a fixed propagation rule:

  • AEGNN recomputes an expanding k-hop neighborhood whenever an event arrives.
  • Streaming GNNs (DGNN) pushes LSTM-based updates to 1-hop neighbors.
  • TGN refreshes only the memory of nodes that interacted, which leaves inactive nodes stale.

Our claim has three parts.

  1. Exactness. In a spiking graph network with leaky integrate-and-fire neurons, the stopping rule for a local update can be the firing threshold itself. Leaky integrate-and-fire neurons sum incoming pulses into a charge that decays over time and fire when the charge crosses a threshold (Venkatesha et al.). With this rule, event-by-event local processing is exact rather than approximate.
  2. Cost. The frontier of nodes touched per event is learned and data-dependent. It can be far smaller than a k-hop ball on graphs with high-degree hubs.
  3. Payoff. Together, these give per-event computation that is both bounded and multiplication-free.

This is different from the closest work. AEGNN localizes updates, but with a fixed radius and floating-point spline convolutions. SpikeNet-style models use additions only, but they are global over each snapshot. Neither uses threshold crossing to decide where computation goes.

The mechanism is the lazy membrane update. Node $i$ stores its membrane charge $V_i$ and the time $t_i$ it was last touched. When an incoming pulse arrives at time $t$, the node first decays its charge and then adds the incoming weights:

$$V_i(t) = V_i(t_i)\, e^{-(t - t_i)/\tau_i} + \sum_{j \in \mathcal{S}(t)} w_{ij}.$$

Here $\tau_i$ is a learned time constant, $\mathcal{S}(t)$ is the set of upstream neurons spiking at $t$, and $w_{ij}$ are synaptic weights. These weights are added, not multiplied, because pulses are binary (Wu et al.). The node fires and subtracts its threshold $\theta_i$ when $V_i \ge \theta_i$. Two facts follow:

  • No spontaneous spikes. Decay with no bias term only pulls charge toward zero, so a neuron that receives no new input cannot start firing. Skipping untouched nodes therefore changes nothing.
  • Bounded residual. Reset-by-subtraction makes each neuron behave like a sigma-delta encoder. Without leak, its cumulative output (number of spikes times $\theta_i$) differs from its cumulative input by less than $\theta_i$. With leak, the same holds for time-discounted input. Below-threshold evidence is therefore held, not discarded.

The decay uses real inter-arrival gaps instead of the fixed per-snapshot leak factor used by SpikeNet and Dy-SIGN. This makes the charge serve as the time-aware forgetting mechanism that DGNN builds with a dedicated LSTM. The decay costs one multiply per touched node, or a shift if $\tau_i$ is restricted to powers of two. We will count it honestly.

Research Program

Model. The architecture is a two- or three-layer spiking message-passing network over a continuous-time interaction stream.

  • Input encoding. Each node's raw features pass once through a dense linear encoder when the node first appears, following the Pre-Linear finding of SGNNBench. The encoder sets a persistent input current. Its floating-point cost is charged once per node, not once per event. This avoids the repeated dense pre-spike attention that ChronoSpike pays in every snapshot.
  • Edge arrival. A new edge $(u, v, t)$ injects a learned edge-type current into the first-layer neurons of $u$ and $v$.
  • Propagation. Any neuron that fires adds its weight row into the next-layer neurons of its current neighbors. These neighbors are found through an adjacency list in the style of the sparse tracking arrays of Feng et al.. The cascade ends when no neuron crosses threshold. In this sense the frontier plays the role of the exact zero-delta boundary that Farhan computes explicitly for distance labels. Here the neurons compute it with no separate bookkeeping.
  • Readout. For a link-prediction query, the two endpoint charge vectors are read out after lazy decay to the query time.

Training. We train with surrogate gradients through the same event-driven forward pass, simulated in batches over truncated windows of consecutive events on a GPU. Because local and global simulation are identical for this model, there is no gap between how it is trained and how it is deployed. Two design choices require care: learned thresholds and gradient stability. For gradient stability we will compare truncated backpropagation through time with the equilibrium-based implicit gradients of Dy-SIGN.

Analysis. We will measure the per-event frontier size, meaning the number of neuron-node pairs that receive input. We will report its distribution against node degree and against the k-hop ball size that AEGNN would touch. We will also test the exactness claim directly: after streaming a full dataset, the local-update states should match a full global resimulation bit for bit, both with and without the no-bias constraint. The version with bias terms allowed shows what the constraint buys.

Deletions. As a secondary study, we handle edge deletions with a retraction event. The retraction injects negative current equal to the deleted edge's decayed past contribution, which is tracked as a per-edge trace. This retraction is exact for current charges but cannot recall pulses that were already sent. Deletions are untested in any spiking graph model in the file, and graph unlearning work such as Yi et al. and Adaptive Graph Unlearning bounds cost by deletion size. We will measure how close retraction comes to retraining from scratch without the edge.

Baselines

Naive full recomputation. The naive reference point is the same trained spiking model, but every node is simulated at every event, or at every snapshot boundary in a snapshot variant. It fixes accuracy, since it must match our outputs exactly, and it sets the cost ceiling. Beating it means equal predictions at a much lower count of additions per event.

Strongest learned competitors on streaming link prediction. These are TGN (Temporal Graph Networks) and the best model on the TGB leaderboard. On tgbl-wiki, TGB reports NAT at MRR 0.749. We will run TGN and NAT from their released TGB configurations, with the same historical-negative protocol, the same data splits, and a matched hyperparameter search budget for our model. Our accuracy goal is to come within a few MRR points of NAT. The efficiency goal is to use an order of magnitude fewer estimated joules per event. The energy estimate uses the per-operation addition and multiply constants in SGNNBench's profiler. Beating NAT outright on MRR is not required to count as success.

Strongest heuristics. The strongest heuristics are EdgeBank and the moving average from TGB. On tgbn-reddit, the moving average reaches NDCG@10 0.559 against TGN's 0.315 (TGB). These cost almost nothing, so they define the floor any learned streaming model must clear on node-affinity tasks.

Strongest spiking competitors on node classification. For snapshot-style node classification on DBLP and Tmall, the strongest spiking competitors are Delay-DSGN and ChronoSpike. ChronoSpike reports beating twelve baselines by 2.0% Macro-F1, and Delay-DSGN reports exceeding Dy-SIGN by over 2% on DBLP. The file contains no absolute F1 values on Lacuna for either model on DBLP or Tmall, so we will rerun both under our splits. We will feed our model the same edges as an event stream, ordered by time inside each snapshot.

Fixed-radius ablation. This ablation isolates the key ingredient. We run our spiking model with an AEGNN-style fixed k-hop update, where every node within k hops is recomputed whether or not anything fires. This keeps the arithmetic and changes only the stopping rule.

Float delta-gated ablation. We also run a floating-point twin of our network in which a node propagates only when its activation changes by more than a learned threshold. This keeps the stopping rule and replaces spikes with float messages. Together the two ablations separate how much of the saving comes from threshold-gated locality and how much from additions-only arithmetic.

Why not just…?

Why not just use EdgeBank or a moving average? On repetitive streams these heuristics are fast and strong. The tgbn-reddit result above shows a heuristic nearly doubling TGN. TGB also reports heuristics at least an order of magnitude faster than neural models at inference. This is a real threat on low-novelty datasets, and we expect to lose to them there. The model justifies itself only on TGB datasets where the TGB authors report that heuristics degrade, and on tasks that need learned node representations, such as classification on Tmall. We will report results separately by dataset novelty rather than averaging them.

Why not just quantize TGN to INT8? Quantization lowers the cost of each operation but keeps the update pattern dense: every interacting node still runs a full recurrent update, and fixed-hop attention touches every sampled neighbor. Spiking models remove multiplies entirely, and SGNNBench measures 27.6–29.9x lower energy for spiking GCNs than for their non-spiking counterpart. We will include an INT8 TGN with energy computed by the same per-operation model. This lets us check whether the advantage survives against a stronger efficient baseline than float32.

Why not just run AEGNN-style local updates with float activations? This is the most serious alternative. AEGNN already reports a 200-fold drop in computation on N-Cars from locality alone. The fixed-radius and float delta-gated ablations answer it directly. One outcome would be that the float delta-gated twin matches our frontier size and accuracy. In that case the spiking contribution reduces to the addition-versus-multiply factor, which only pays off on neuromorphic chips. Loihi results such as Tang and TrueNorth results such as Martí et al. suggest that factor is substantial on that hardware. We would report the outcome as a hardware-conditional result rather than a general one. The other outcome would be that firing thresholds give tighter frontiers, because binary firing is sparser than float change detection at matched accuracy. That would confirm the core claim.

Why not just shrink SpikeNet's snapshots to one event each? Global evaluation per snapshot then runs once per edge, so cost grows with graph size times stream length. On the 2.7M-node Patent graph this is infeasible; baselines in the Delay-DSGN study already failed there under far coarser snapshots. We will measure this curve on smaller graphs to show where it crosses ours.

Proposed Experiments and Decisive Checks

Benchmarks.

  • Streaming link prediction: tgbl-wiki and the larger TGB link datasets, using the historical-negative ranking protocol, plus Wikipedia, Reddit, and Twitter as in TGN.
  • Node affinity: tgbn-reddit.
  • Message streams: UCI, where DGNN reports MRR 0.0342.
  • Classification: DBLP and Tmall, for continuity with spiking dynamic graph work.
  • Generality probe (optional): a geometric event graph on N-Cars, where AEGNN reports 94.5% accuracy, to test whether threshold-gated frontiers beat fixed k-hop updates on AEGNN's own ground.

Metrics.

  • Accuracy: MRR, NDCG@10, and Macro/Micro-F1.
  • Cost: additions and multiplies per event, and estimated energy per event from the SGNNBench constants.
  • Frontier: frontier size against degree.
  • Latency: wall-clock time per event on CPU.
  • Hardware (if available): a Loihi-class deployment of the smallest configuration.

Decisive checks. Five results would settle the proposal:

  1. Local and global simulation produce identical states on every dataset. If they do not, the exactness claim fails.
  2. Median frontier size stays roughly flat as endpoint degree grows, while the k-hop ball grows with degree.
  3. The model outperforms the float delta-gated twin on energy per event at equal accuracy. If it only ties, the claim narrows to hardware.
  4. The model comes within a few MRR points of NAT's 0.749 on tgbl-wiki while using at least ten times less estimated energy per event than TGN.
  5. On tgbn-reddit, the model clears the 0.559 moving-average floor. Failing this would show the spiking model learns less than a counter does on node-affinity tasks.