🤖 AI

A Formal Tool for Verification of Probabilistic Spiking Neural Networks Based on Quotient Abstractions

This paper introduces CogSpike, a unified toolchain that employs a novel weight-discretized quotient abstraction to overcome state space explosion in the formal verification of probabilistic Spiking Neural Networks, enabling the analysis of previously intractable networks while providing rigorous correctness guarantees.

Original authors: Nikan Zandian Jazi, Elisabetta De Maria, Christopher Leturc

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nikan Zandian Jazi, Elisabetta De Maria, Christopher Leturc

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to understand how a tiny, complex city of neurons works. In the real brain, these neurons are messy. They don't just fire like perfect light switches; they are influenced by static electricity, unreliable connections, and random noise. To study them, scientists use Spiking Neural Networks (SNNs), which are computer models that try to mimic this messy, biological reality.

The problem is that because these models are so realistic and "noisy," they are incredibly hard to check for errors. It's like trying to predict the exact path of every single raindrop in a storm. If you try to map out every possible outcome for a network of just a few neurons, the number of possibilities explodes into a number so huge that even the fastest supercomputers can't handle it. This is called the "state space explosion."

This paper introduces a new tool called CogSpike and a clever mathematical trick to solve this problem. Here is how it works, using simple analogies:

1. The Problem: The "Too Many Possibilities" Trap

Imagine you are trying to verify that a traffic light system works correctly.

The Old Way (Naïve Approach): You try to track every single car, every exact speed, and every possible weather condition. The number of scenarios becomes infinite. You can never finish checking them all.
The Previous "Shortcut": Some researchers tried to group cars together. They said, "Let's just call all cars 'vehicles' and ignore whether they are red, blue, or fast." But this was too simple. In a neural network, the strength of a connection (a "synaptic weight") matters just as much as the color of a car. If you ignore the strength, you lose the ability to tell if a neuron will actually fire or not.

2. The Solution: The "Pixelated Map" (Weight Discretization)

The authors created a new way to simplify the model without losing the important details. Think of it like taking a high-definition photo and turning it into a pixelated image.

The Trick: Instead of tracking synaptic weights as precise, continuous numbers (like 47.32 or 99.81), they round them off to small, whole numbers (like 1, 2, or 3).
Why it works: Imagine you are grading a test. Instead of giving a score of 87.43, you just say "Good" (3), "Okay" (2), or "Needs Work" (1). You lose the tiny decimal details, but you keep the relative difference. A "Good" student is still clearly better than an "Okay" one.
The Result: This "pixelation" shrinks the massive, impossible-to-solve map of possibilities down into a tiny, manageable grid.

3. The Safety Net: "The Gray Zone" and "The Silent Room"

You might worry: "If we round off the numbers, won't we make mistakes? What if a neuron fires when it shouldn't?"

The paper provides two mathematical guarantees (proofs) to ensure the tool is safe:

The Gray Zone: They admit that for a tiny range of "borderline" cases (the "gray zone"), the simplified model might make a different decision than the super-precise model. However, they proved this zone is very small and bounded. It's like a foggy area on a map; you know exactly how big the fog is, so you know where your uncertainty lies.
The Silent Room: They proved that if a neuron stops getting input, it will eventually fall completely silent and stay silent forever. This is a crucial guarantee: the simplified model won't accidentally invent "ghost" activity that shouldn't be there.

4. The Tool: CogSpike (The "All-in-One Workshop")

The authors didn't just do the math; they built a software workshop called CogSpike.

Design: You can draw your neural network (like drawing a circuit board).
Simulate: You can run a simulation to see how it behaves in real-time.
Verify: This is the magic part. CogSpike automatically translates your drawing into the "pixelated" math model and runs a rigorous check to prove that the network behaves correctly according to specific rules (e.g., "Will this neuron ever fire if no one talks to it?").
Isomorphism: The tool ensures that the simulation you watch and the math you check are exact twins. They speak the same language, so the results are trustworthy.

5. The Payoff: Exponential Power

The paper tested this on seven different network shapes (like chains, forks, and diamonds).

The Magic Number: For every single neuron added to the network, the new method made the problem 17 times smaller to solve.
The Impact: In the old way, a network with 4 neurons might be impossible to check because the computer runs out of memory. With this new method, that same network becomes easy to check. It turns an impossible puzzle into a solvable one.

Summary

In short, the authors built a tool that lets scientists check the safety and behavior of complex, noisy brain models. They did this by creating a "smart shortcut" that rounds off tiny details (like pixelating a photo) but keeps the big picture clear. They proved mathematically that this shortcut is safe, and they built a software workshop that lets anyone design, simulate, and verify these networks without needing a supercomputer.

Technical Summary: A Formal Tool for Verification of Probabilistic Spiking Neural Networks Based on Quotient Abstractions

1. Problem Statement

Spiking Neural Networks (SNNs) offer a more biologically faithful model of neural dynamics than classical artificial networks, particularly due to their stochastic, event-driven nature rooted in ion-channel noise and unreliable synaptic vesicle release. While probabilistic models are mathematically necessary to capture this behavior, their formal verification via probabilistic model checking faces a fundamental barrier: the state space explosion problem.

When encoding an SNN as a Discrete-Time Markov Chain (DTMC) for tools like PRISM, the state space grows exponentially with the number of neurons. This renders verification intractable for networks larger than a handful of neurons. Existing approaches face a trade-off:

Biological Fidelity vs. Tractability: Continuous-state stochastic models (e.g., using escape or diffusive noise) are biologically realistic but do not yield discrete-state models amenable to exhaustive formal verification.
Naïve Abstraction Limitations: General-purpose quotient model abstractions can reduce state spaces by partitioning membrane potentials into equivalence classes. However, a naïve application to SNNs discards critical synaptic weight information, collapsing strong and weak excitatory or inhibitory contributions into indistinguishable classes, thereby limiting the verifiable properties.

2. Methodology

The paper proposes CogSpike, a unified workbench that integrates SNN design, simulation, and formal verification within a single isomorphic tool chain. The core innovation is a weight-discretized quotient model abstraction that resolves the limitations of naïve quotient models while enabling formal analysis.

2.1 Weight-Discretized Quotient Abstraction

The methodology introduces a discretization scheme that maps continuous synaptic weights to a compact integer range while preserving the relative contribution of each synapse.

Discretization Function: Continuous weights $w \in [-w_{max}, w_{max}]$ are mapped to a discrete range $[-W, W]$ using the function $\delta_W(w) = \lfloor w \cdot \frac{W}{w_{max}} \rceil$ .
Preservation of Dynamics: Unlike naïve abstractions, this scheme retains the weighted sum of incoming spikes ( $C_n = \sum w^d_i \cdot y_i$ ) in the state evolution, distinguishing between different synaptic strengths.
Threshold Calibration: The firing threshold is conservatively calibrated as $T_d = \lceil T \cdot \frac{W}{w_{max}} \rceil$ to ensure the discretized neuron is at least as hard to fire as the original, preventing spurious firing.
Multiplicative Leak: The update rule $p'_n = \lfloor r \cdot p_n \rfloor + C_n$ maintains strict decay in the absence of input, ensuring isomorphism between the simulation engine and the PRISM model.

2.2 Formal Correctness Guarantees

The paper provides two key theorems to bound the errors introduced by discretization:

Two-Sided Discretization Fidelity (Theorem 1): This theorem confines any firing disagreement between the original and discretized models to a bounded "gray zone" around the threshold. It provides a constructive rule for choosing the discretization parameter $W$ to ensure that inputs with sufficient margin ( $S - T \geq \gamma$ ) are correctly classified as firing or non-firing.
Asymptotic Silence (Theorem 2): This theorem guarantees that unforced neurons (those below threshold with no input) will fall permanently silent. Due to the multiplicative leak and floor operation, the membrane potential strictly decreases to zero, ensuring that the discretized model does not exhibit spurious sustained firing in the limit.

2.3 The CogSpike Workbench

CogSpike is implemented in Rust and features:

Visual Graph Editor: For constructing SNN topologies with configurable weights and input generators (periodic, Poisson, burst).
Isomorphic Simulation Engine: Executes LIF dynamics with three presets (Deterministic, Fast, Full) that trade biological fidelity for computational speed.
Automated PRISM Code Generation: Translates the SNN graph into a DTMC model supporting both precise and weight-discretized quotient abstractions. It synthesizes PCTL properties for reachability, safety, and liveness.
Verification Bridge: Invokes PRISM as a background process, parsing results and displaying them alongside simulation data.

3. Key Contributions

The paper outlines four primary contributions:

Weight Discretization Scheme: A method to map continuous weights to a finite discrete range while preserving threshold feasibility and relative synaptic contributions.
Formal Correctness Proofs: The derivation of the two-sided discretization-fidelity theorem and the asymptotic silence theorem, providing exact limits on the abstraction's accuracy.
Topology-Dependent Scaling Analysis: Closed-form formulas for DTMC size as a function of network structure, validated empirically across seven canonical topologies.
CogSpike Tool: A unified workbench enabling a seamless design–simulate–verify workflow, where the simulation engine and the formal model are mathematically isomorphic.

4. Results

The authors validated their approach across seven canonical topologies (single, chain-2 through chain-4, fork, diamond, convergent) using three configurations (Deterministic, Fast, Full) and varying discretization parameters ( $W=2, W=3$ ).

State Space Reduction: The weight-discretized abstraction achieves an exponential reduction in state space. For a chain of neurons with $W=3$ $W = 3$ , the reduction factor is approximately 17.3× per neuron.
- Example: A 4-neuron chain in the "Full" precise configuration has 362,289 reachable states. The same chain with $W=3$ discretization has only 88 states.
Scalability: While precise models hit memory limits (Out-of-Memory errors with the CUDD BDD engine) at small scales (e.g., a 5-neuron diamond topology), the discretized models remain tractable.
- The "Full" precise model for a 5-neuron diamond topology failed (OOM), whereas the discretized version completed with 98 states.
- Discretization allows the verification of networks that are otherwise intractable, extending the verifiable range from ~4 neurons (precise) to >10 neurons (discretized) depending on the topology.
Topology Sensitivity: The analysis revealed that fan-out topologies (e.g., fork) are more expensive to verify than fan-in topologies (e.g., convergent) due to the multiplication of module counts in parallel branches.

5. Significance and Claims

The paper claims to resolve the tension between biological fidelity and computational tractability in SNN verification. By introducing a weight-discretized quotient abstraction, the authors demonstrate that it is possible to:

Preserve Core Biological Properties: The discretized model maintains tonic spiking, integrator behavior, and excitability under multiplicative-leak dynamics.
Enable Exhaustive Verification: The state space reduction compounds exponentially, enabling the formal verification of probabilistic SNNs that were previously too large for model checking.
Unify Simulation and Verification: CogSpike eliminates the gap between simulation and formal analysis by ensuring the underlying mathematical models are isomorphic, allowing verification results to faithfully analyze simulation behavior without manual model construction.

The authors position this work as a Pareto compromise, offering a model that is sufficiently biologically faithful to capture stochastic dynamics while remaining compact enough for rigorous formal analysis via PRISM. The paper explicitly notes that the "gray zone" of firing disagreement is intrinsic to the compression regime but is bounded and manageable, with the asymptotic silence guarantee providing a robust safety net for unforced neurons.