Advancing Fault-Tolerant Quantum Computing with GPU-Accelerated Simulation
NVIDIA and Jülich researchers successfully simulated magic-state preparation in a 104-qubit protocol using 8,192 GPUs on JUPITER, with development and validation supported by the NVIDIA Accelerated Quantum Research Center (NVAQC).
Building a useful fault-tolerant quantum computer requires more than protecting stored quantum information. It also requires reliably performing the operations that give quantum algorithms their computational power. In leading error-corrected architectures, specially prepared quantum states called magic states supply an essential ingredient for these operations.
Producing high-quality magic states can consume a substantial share of a quantum computer’s resources and represent a significant design uncertainty. Understanding how their preparation responds to hardware imperfections is therefore central to designing a quantum processor, choosing its error-correction scheme, and predicting the performance of applications running on it.
NVIDIA and Jülich Supercomputing Centre researchers are tackling this challenge using NVIDIA CUDA-Q and NVIDIA cuQuantum to run simulations on JUPITER - Europe’s first exascale supercomputer, built by Bull. The collaboration brings detailed quantum circuit modeling together with GPU-accelerated simulation and distributed numerical analysis. The largest run in the project used 8,192 NVIDIA GH200 GPUs to model a magic-state preparation protocol spanning 104 physical qubits.
The campaign combined development and validation at the NVAQC with large-scale execution on JUPITER. This allowed the team to test and refine the simulation software on the NVAQC in parallel with the largest experiments running on JUPITER - showing how the NVAQC can accelerate work at leading supercomputing centers.
Modeling the operations that enable fault tolerance
Many operations used in quantum error correction belong to a class called Clifford operations, which can be efficiently simulated under suitable noise assumptions. But performing full, universal, quantum computation requires augmenting Clifford operations with a least one more non-trivial example. Magic states enable this, and simulations involving them are consequently much more difficult. Nevertheless, simulating the preparation of magic states with detailed hardware errors is essential to understand and improve how thery can be created. This requires simulation methods capable of retaining quantum behavior that simpler models can miss.
The study focuses on a component of a protocol called magic-state cultivation: preparing a state in a small error-correcting code, checking it for faults, and growing into large code distances. The simulated protocol starts with a distance-3 color code, uses recently designed additional flag measurements to detect harmful faults, and grows into a distance-7 hybrid color/surface-code configuration before further error-correction rounds and readout. The 104-qubit count for simulating this process includes the data and auxiliary qubits used across the sequence.
The model simulated on JUPITER includes coherent phase errors, which can accumulate and interfere, and leakage, in which a superconducting qubit leaves its usual two computational levels. Selected physical sites are therefore modeled with a third energy level, significantly increasing the complexity of the simulation. These mechanisms let researchers examine behavior beyond a model of random bit and phase flips, while retaining the actual non-Clifford operations that prepare the magic state.
This provides a controlled setting for studying how particular hardware errors propagate through the preparation circuit and its checks. The longer-term objective is to connect that behavior to the quality and cost of the logical operations that an application consumes.
Bringing a 104-qubit protocol onto thousands of GPUs
A direct state-vector representation grows exponentially with the number of quantum degrees of freedom. Adding a third level to represent leakage increases that memory requirement further. Reaching the target 104 qubit therefore required new circuit representations and execution tools alongside the GPU hardware.
The simulator reorganizes operations while preserving their dependencies and measurement statistics, and reuses storage as qubits are measured and released. It also packs groups of three-level systems into a binary representation that cuQuantum’s cuStateVec library can execute. For example, five three-level systems have 243 basis states and fit within eight binary storage bits, which provide 256 entries. These techniques allow the simulator to follow the 104-qubit protocol while storing a smaller evolving quantum state. In the 8,192-GPU configuration, a 45-bit encoded register represents approximately 35.2 trillion complex amplitudes. In double precision, the state alone occupies 512 TiB of distributed GPU memory, or 64 GiB per GPU, leaving additional memory for communication and numerical analysis.
The project also developed distributed factorization tools using NVIDIA cuBLASMp and cuSOLVERMp. These tools examine selected partitions of the stored state to investigate how much information a more compact representation must retain. This creates a route toward testing approximate simulation methods against a detailed state-vector reference. The reference simulation continues from the original state, preserving the trajectory being studied.
Building a yardstick for larger simulations
The 8,912 GPU job on JUPITER is one part of a broader simulation campaign. Smaller runs provide a practical yardstick for estimating the GPU requirements and computational cost of larger experiments before committing substantial supercomputing time.
The workflow starts from a precisely specified circuit and noise model. Its encoded state size determines the base memory requirement. Measurements of execution, communication, and analysis then inform resource planning. Benchmarks distinguish the time spent evolving the quantum state from initialization and factorization, which can have different scaling behavior.
That distinction matters when extending the model. Adding one binary storage bit doubles state-vector memory, but elapsed time also depends on gate placement, communication, and the analysis requested. GPU count multiplied by runtime gives a corresponding GPU-hour budget. Together, these quantities support decisions about which experiment to run, where to run it, and how much capacity to reserve.
The NVAQC provided a setting for developing the tools, testing configurations from a few GPUs to hundreds, and checking results with independent simulation methods. These activities proceeded alongside the large jobs on JUPITER, allowing software qualification and scientific validation to continue without waiting for the largest allocations. In small packed-circuit validation cases at the NVAQC, independent state-vector and tensor-network calculations agreed on measurement probabilities to approximately 10⁻¹³ when the tensor-network truncation threshold was tightened.
The same approach can support future studies with different leakage models, circuit schedules, and error-correction protocols. Each new workload can be checked at manageable scale, assigned a memory budget, and benchmarked before extending it to larger configurations.
For quantum processor designers, these simulations provide a way to investigate which hardware imperfections deserve closer attention and how error-control choices respond to them. For application researchers, they lay groundwork for connecting the behavior of noisy magic-state preparation to logical-operation quality and application performance. The combination of detailed reference simulations and tested approximations can make those design questions increasingly accessible.
Explore NVIDIA cuQuantum for GPU-accelerated quantum simulation and CUDA-Q for quantum programming and research workflows.