⚛️ quantum physics

GPU-Accelerated Quantum Simulation of Stabilizer Circuits

This paper introduces QuaSARQ, a GPU-accelerated simulator that employs novel parallel algorithms for stabilizer circuit evolution and measurements to achieve up to 105× speedups and over 80% energy reduction compared to state-of-the-art CPU and GPU simulators, enabling efficient simulation of circuits with up to 180,000 qubits.

Original authors: Muhammad Osama, Dimitrios Thanos, Alfons Laarman

Published 2026-09-24

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Muhammad Osama, Dimitrios Thanos, Alfons Laarman

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

In the quest to build a working quantum computer, scientists face a paradox: to prove a machine works, they must first simulate its behavior on a classical computer. But simulating a quantum system is notoriously difficult because the amount of information required to describe it grows explosively with every added particle. A single quantum bit, or qubit, can exist in a state of superposition, representing both 0 and 1 simultaneously. When you link many qubits together, their combined state becomes a vast, complex web of possibilities that is incredibly hard to track. However, there is a special class of quantum circuits, known as stabilizer circuits, that behave in a more predictable way. These circuits use a specific set of operations that, while powerful enough to test error correction and communication protocols, do not create the full, chaotic complexity of a universal quantum computer. Because of this structure, they can be simulated on classical machines, but only if the simulation is clever enough to avoid getting bogged down by the sheer volume of data.

The challenge has been that as these circuits grow larger—reaching tens of thousands of qubits and millions of operations—traditional simulation methods hit a wall. They struggle particularly when the circuit includes measurements, which are the moments where the quantum state is observed and forced to collapse into a definite result. These measurements introduce randomness and require the computer to constantly reorganize its internal data structure, a process that becomes painfully slow and sequential on standard processors. Researchers at Leiden University have now introduced a new approach that bypasses these bottlenecks by moving the entire simulation onto a graphics processing unit, or GPU. These chips, originally designed to render video games, are built to perform thousands of simple calculations simultaneously, making them ideal for the kind of massive, parallel data crunching required to simulate large quantum circuits.

The team, led by Muhammad Osama, Dimitrios Thanos, and Alfons Laarman, developed a new simulator called QuaSARQ. Instead of trying to force the old, sequential methods to run faster, they completely rewrote the underlying algorithms to fit the GPU's architecture. In a standard simulation, updating the state of a quantum circuit after a measurement often involves a step-by-step process similar to solving a complex puzzle where you cannot move the next piece until the current one is placed. This creates a chain of dependencies that slows everything down. The researchers redesigned this process so that the GPU can handle thousands of these updates at the same time. They achieved this by organizing the data in a way that allows the memory to be accessed in smooth, continuous streams, eliminating the pauses and conflicts that usually occur when many processors try to read and write to the same memory space at once.

A key innovation in their work is how they handle the "pivot" points during the simulation. When a measurement occurs, the simulator must identify which parts of the quantum state are affected and update them. In previous methods, finding these affected parts was a slow, searching process that varied wildly depending on the specific circuit. The new method packs these search results into a tight, compact list, allowing the GPU to process them in a single, efficient pass. Furthermore, they replaced the traditional step-by-step elimination of data with a parallel technique that calculates the necessary changes in three coordinated sweeps. This allows the simulator to handle circuits with up to 180,000 qubits and depths of 1,000 layers, a scale that was previously out of reach for many existing tools.

The results of their testing were striking. When compared against the fastest existing simulators, including the highly optimized CPU-based tool known as Stim, QuaSARQ demonstrated a massive improvement in speed. On the most demanding test cases, the new simulator ran up to 105 times faster than its competitors. Beyond raw speed, the efficiency gains were equally significant. Because the GPU completed the tasks so much more quickly, it consumed over 80 percent less energy than the CPU-based alternatives. This is a crucial finding, as the energy cost of running large-scale simulations is becoming a major concern for researchers. The new tool also excelled at "many-shot" sampling, a process where the same circuit is run thousands of times to build a statistical picture of its behavior. While other simulators slowed down significantly as the number of required samples increased, QuaSARQ maintained a steady, rapid pace, handling thousands of shots with ease.

The researchers tested their system against a broad suite of benchmarks, ranging from small circuits to massive ones with 180,000 qubits. In these tests, QuaSARQ consistently outperformed not only Stim but also other leading software packages like Qiskit-Aer, Qibo, Cirq, and PennyLane. In one specific comparison, while the leading CPU simulator managed to complete 125 circuits within a 132-hour window, QuaSARQ finished 177 circuits in just 72 hours. The advantage was particularly pronounced in circuits with many measurements, where the new parallel algorithms prevented the simulation from stalling. The team noted that their approach does not just make existing simulations faster; it enables the simulation of quantum circuits at a scale that was previously impossible to study in detail.

This work suggests that the path to understanding complex quantum systems may lie in adapting classical hardware to think in parallel rather than in sequence. By rethinking how data is stored and how updates are calculated, the researchers have shown that the limitations of current simulators are not fundamental laws of physics, but rather engineering challenges that can be solved. The success of QuaSARQ indicates that for the specific class of stabilizer circuits, the combination of specialized algorithms and modern GPU hardware can provide a powerful tool for verifying quantum error correction and designing future quantum protocols. While this does not solve the simulation problem for all types of quantum circuits, it provides a robust and efficient method for a foundational class of problems that are critical to the development of reliable quantum computers. The findings offer a clear demonstration that with the right approach, the computational barriers to simulating large-scale quantum behavior can be significantly lowered.

Technical Summary: GPU-Accelerated Quantum Simulation of Stabilizer Circuits

Problem Statement

Classical simulation of quantum circuits is essential for algorithm design, verification, and optimization. While general state-vector simulators exist, they suffer from exponential memory scaling, limiting them to approximately 30 qubits. Stabilizer (Clifford) circuits, which are non-universal but classically simulatable via the Gottesman-Knill theorem, offer a pathway to larger-scale simulation using the stabilizer-tableau formalism.

However, existing high-performance simulators face significant bottlenecks when scaling to large qubit counts and extensive measurement workloads:

Sequential Dependencies: Key operations in stabilizer simulation, such as Gaussian elimination (GE) for handling projective measurements, traditionally rely on sequential dependencies (e.g., in the CHP algorithm or Stim's CX injections) that hinder parallelization.
Memory Access Patterns: Standard implementations often result in irregular memory access and warp divergence on GPUs, particularly during pivot selection and measurement updates.
Sampling Efficiency: "Many-shot" sampling (running the same circuit thousands of times) is computationally expensive if the full tableau must be re-updated for every shot.
GPU Adaptation Gap: While state-of-the-art CPU simulators like Stim utilize SIMD instructions and Pauli frames, their algorithms have not been fully adapted to exploit modern GPU architectures. Previous attempts to port stabilizer simulation to GPUs have yielded limited speedups due to these architectural mismatches.

Methodology

The authors introduce QuaSARQ, a GPU-accelerated stabilizer simulator designed to overcome these bottlenecks through a suite of parallel algorithms tailored for the CUDA architecture. The methodology focuses on three core areas:

1. Data-Parallel Tableau Evolution and Scheduling

Host-Side Scheduling: The input circuit is decomposed into "maximal windows" of mutually independent gates. This allows large batches of Clifford gates to be applied simultaneously on the GPU, maximizing parallelism before any device execution begins.
Dual Tableau Layout: To optimize for both gate application and measurement, the simulator employs a dual-layout strategy:
- Column-Major: Used for applying Clifford gates, ensuring contiguous access to generator bits for a single qubit.
- Row-Major: Used for measurement operations, ensuring contiguous access to qubit bits across all generators.
- In-Place Transpose: A specialized two-stage GPU kernel (Algorithm 4) performs an in-place transpose between these layouts using tile-based bit-shuffling in shared memory, avoiding the overhead of allocating new buffers.

2. Parallelizing Measurement and Gaussian Elimination

The most significant contribution is the reformulation of the measurement update process to eliminate sequential dependencies:

Pivot Compaction: Instead of scanning the entire tableau for anti-commuting generators (which causes warp divergence), the authors use stream compaction (Algorithm 6) to pack all relevant pivot indices into a dense, contiguous array. This ensures coalesced memory access during subsequent steps.
Three-Pass Prefix-XOR Elimination: The sequential nature of Stim's CX injections (where the control generator's state evolves with each target) is transformed into a parallel problem.
- The authors unfold the sequential recurrence into a prefix-XOR (scan) operation over the target generators.
- Using a three-pass kernel approach (Algorithm 7), they compute block-local prefixes, perform a device-wide scan on block sums, and finally merge these to apply all CX injections in parallel. This eliminates the loop-carried dependency that previously forced sequential execution.
Sign Aggregation: To handle sign updates without excessive atomic contention, the authors employ a binary-tree reduction scheme within shared memory (Algorithm 3), collapsing thread-local signs before applying a single atomic update per block.

3. Many-Shot Sampling via Pauli Frames

For sampling workloads requiring thousands of shots, QuaSARQ utilizes Pauli frames (Algorithm 9). Instead of collapsing the tableau for every shot, the simulator tracks random bit-flips and phase-flips in a packed matrix. This allows $w$ shots (where $w$ is the word size, e.g., 64) to be processed in parallel for all measured qubits simultaneously, decoupling sampling cost from the number of shots.

Key Contributions

The paper presents the following specific technical contributions:

A Host-Side Scheduler: Arranges gates into maximal parallel windows to maximize GPU throughput.
Dual Tableau Layout: A column-major layout for gates and a row-major layout for measurements, connected by an efficient in-place transpose kernel.
Tree-Based Sign Collapsing: A method to aggregate sign updates using shared memory reductions to minimize global atomic operations.
Dense Stream Compaction: Packing anti-commuting pivots into contiguous memory to eliminate warp divergence during measurement updates.
Three-Pass Prefix-XOR Gaussian Elimination: A novel reformulation of Stim's measurement algorithm that transforms sequential CX injections into fully parallel prefix operations, removing sequential dependencies.
QuaSARQ Implementation: A complete GPU simulator implementing these algorithms, capable of handling circuits up to 180,000 qubits.

Results

The authors evaluated QuaSARQ against state-of-the-art simulators including Stim (CPU), Qiskit-Aer (CPU/GPU), Qibo, Cirq, and PennyLane on a benchmark suite ranging from 100 to 180,000 qubits and depths up to 1,000.

Runtime Performance:
- QuaSARQ achieved speedups of up to 105× compared to Stim on demanding instances (e.g., 12,000 qubits, depth 100).
- On the "heavy" benchmark suite (1K–180K qubits), QuaSARQ completed 177 circuits within 72 hours, whereas Stim completed only 125 circuits in 132 hours.
- For many-shot sampling (1,024 shots), QuaSARQ demonstrated flat runtime scaling across circuit sizes, while Stim's sampling cost increased steeply.
Energy Efficiency:
- QuaSARQ reduced energy consumption by over 80% on average for simulation tasks and by more than 90% for sampling tasks compared to CPU-based alternatives.
Scalability:
- The simulator successfully handled circuits with up to 180,000 qubits and 130 million gates.
- Unlike Stim, which often times out or collapses only a few qubits in highly nondeterministic circuits, QuaSARQ successfully processed thousands of nondeterministic measurements even at 100,000 qubits.

Significance and Claims

The paper claims that QuaSARQ demonstrates that GPU-oriented algorithms can significantly advance the scalability of stabilizer-circuit simulation, particularly for workloads involving extensive measurements and sampling.

The authors emphasize that their parallel algorithms successfully address the specific challenges of tableau evolution and projective measurements that have previously limited GPU adoption in this domain. By reformulating sequential dependencies (specifically in Gaussian elimination) into parallel primitives (prefix-XOR and stream compaction), they achieve a level of performance and energy efficiency that outperforms the current state-of-the-art CPU simulator (Stim) and other general-purpose quantum simulators. The work validates that with appropriate algorithmic restructuring, GPUs can handle large-scale stabilizer simulations that were previously intractable or inefficient on CPU-only architectures.