FaultScope software pinpoints errors in quantum error correction circuits

Researchers at Tsinghua University and the Beijing Institute of Mathematical Sciences and Applications have created FaultScope, a new classical simulator for quantum error correction circuits implemented in Rust with a Python interface. Unlike existing methods, FaultScope estimates logical error rates and their derivatives from the same data, eliminating the need for repeated simulations. These derivatives pinpoint “noise hotspots”, individual components contributing most to errors, enabling targeted noise reduction for more efficient quantum computing architectures. The software demonstrated the lowest runtime among tested simulators, with derivative calculations adding less than one percent to overall processing time.

Rust Implementation of FaultScope for QEC Simulation

This combination of languages allows developers to use Rust’s performance benefits alongside Python’s usability and extensive scientific computing libraries. The simulator’s core is designed for efficient error attribution, an important step in optimizing quantum hardware and algorithms. This approach streamlines the analysis of quantum error correction schemes and significantly reduces computational overhead. Instead of requiring separate runs to determine error rates and sensitivities, FaultScope performs both calculations simultaneously, offering a substantial efficiency gain for researchers.

FaultScope supports two distinct simulation pathways: forward simulation of Clifford circuits and direct sampling from detector error models. Forward simulation propagates Pauli errors through the circuit using a compiled representation of ideal measurement relations, while direct sampling bypasses the circuit simulation and directly generates outcomes based on detector error models.

Both methods use a compact data storage format and allow for detailed sensitivity summaries, enabling analysis at various levels of the circuit, from individual qubits to entire operations. The efficiency of FaultScope is demonstrated by its runtime performance compared to other established simulators. Across five repetition code sizes ranging from 7 to 2047 error locations, calculating all derivatives adds only 0.33-0.97% to the time required for estimating logical error rates.

In benchmarks, the simulator consistently achieved the lowest runtime among tested tools, completing a circuit with a distance of 100 in 2043.1 seconds, while SymFT timed out at distances of 30 or greater. By pinpointing these specific sources of noise, researchers can focus their efforts on targeted noise reduction strategies. Circuit-level simulations using surface codes and high-rate lifted-product codes indicate that addressing these hotspots yields a more substantial reduction in logical error rates than applying interventions randomly.

The simulator’s architecture relies on pre-compiling ideal measurement relations for forward simulation or error signatures for direct sampling, reusing these elements across multiple shot batches. During execution, event masks bypass decoding and combine with a loss mask to estimate all sensitivities, streamlining the process and maximizing efficiency. The resulting data is stored in a compact format, facilitating detailed analysis and identification of noise hotspots. The ability to efficiently identify and address noise hotspots promises to accelerate the development of more robust and reliable quantum computers.

FaultScope Estimates Logical Error Rates and Sensitivities

FaultScope software estimates the impact of individual noisy components on overall quantum error correction performance, a capability enabled by its ability to calculate logical error rate derivatives from the same data used to assess those rates. This eliminates the need for repeated simulations or alterations to the decoding process, representing a significant efficiency gain in the pursuit of stable quantum computation. The software’s core innovation lies in its error attribution scheme, which identifies components where targeted noise reduction will yield the most substantial improvements to quantum error correction (QEC) performance.

These improvements are quantified as “sensitivities,” defined within the work as the derivative of the logical error rate with respect to the error rate of each noisy component. Each sensitivity measurement reveals the difference in the probability of logical failure with and without an error at that specific component, effectively creating a “hotspot map” of the circuit’s vulnerabilities.

When intervention resources are limited, this map guides researchers to focus noise reduction efforts on these hotspots, demonstrably lowering the logical error rate more effectively than random component selection. To estimate sensitivities, FaultScope uses Monte Carlo methods, simulating numerous independent shots of a QEC memory experiment. The software’s efficiency is highlighted by benchmarks showing minimal computational overhead; for repetition code circuits with 7 to 2047 noisy components and 100,000 shots per run, calculating all sensitivities increased median total runtime by only 0.97% relative to estimating the logical error rate without event recording.

This speed is further demonstrated by comparisons against six other CPU simulators on random Clifford and surface code circuits, where FaultScope consistently achieved the lowest median runtime at every circuit size. The sum of sensitivities for a group of components, $S_G$, represents the collective impact of that group on the overall logical error rate.

Researchers can then use these sensitivities to predict the decrease in logical error rate achievable by reducing the error rates of specific components by a fixed amount, δ $p_j$. This prediction, combined with the cost of intervention, guides the selection of components to target under budgetary constraints.

While the study acknowledges that a fixed shot budget may be insufficient to resolve sensitivity differences at very low logical error rates, the software provides an important tool for optimizing QEC schemes. The ability to efficiently estimate all sensitivities from the same simulation records, without modifying the decoder, positions FaultScope as a valuable asset in the design and optimization of fault-tolerant quantum computing architectures.

Error Attribution Identifies Noise Hotspots in QEC

FaultScope, a new software package, identifies specific components within quantum error correction circuits that contribute most to errors, a capability important for targeted noise reduction. This approach allows researchers to create a “hotspot map” of noisy components, guiding interventions for maximum impact on logical error rates. The software’s core is built in Rust, with a Python interface, offering a combination intended to balance performance with usability for developers familiar with both languages.

Unlike existing methods, FaultScope achieves this error attribution by calculating sensitivities from a single batch of sampled errors and decoded outcomes, streamlining the process and minimizing computational demands. Circuit-level simulations using surface codes and lifted-product codes demonstrate that focusing noise reduction efforts on these identified hotspots yields substantially greater improvements than random interventions.

Benchmarking reveals FaultScope’s speed advantage over other simulators, achieving a median speedup of 1.70x over Stim for random Clifford circuits with 1024 qubits and 64 layers. It is the only tested simulator to successfully complete a large-scale surface code case, with a distance of 100 and a Pauli noise level of ${10}^{–3}$, within established resource limits. The software’s efficiency is further demonstrated by the minimal runtime increase, ranging from 0.33% to 0.97%.

“FaultScope allows a QEC performance evaluation to guide subsequent noise reduction,” the researchers state, highlighting the software’s potential to accelerate the development of fault-tolerant quantum computing architectures. The software stores event records in a compact format, supporting sensitivity summaries categorized by qubit, gate, round, or operation, enabling analysis at various levels of circuit complexity.

Detector error models are represented as independent events with probabilities, each defined by a signature specifying which detectors and logical observables are affected. Every evaluation uses 100,000 shots, and the tool distinguishes between baseline logical error rate (LER) estimation, LER with retained error events, and full attribution workflows including sensitivity calculations. The team reports that the attribution workflow adds less than 1% to the runtime of logical error rate estimation, even for larger code sizes.

The software’s design minimizes memory overhead, requiring only O(MB) words to store event masks, which are not retained when attribution is disabled. The researchers emphasize that this integration of error attribution into QEC simulation is now achievable.

Performance Benchmarks Show FaultScope Runtime Efficiency

FaultScope outperforms existing quantum error correction simulators in benchmark tests, completing simulations at sizes where others time out or encounter errors. These optimizations allow FaultScope to generate measurement records directly in the format required by decoders, avoiding time-consuming data conversions and streamlining the simulation process. The ability to derive sensitivities without additional computation is a key differentiator, allowing for rapid error attribution and targeted noise reduction strategies. The software’s performance is not limited to random circuits; it also demonstrates efficiency with surface code memories.

At a distance of 70, FaultScope completed the simulation in 618.8 seconds, while Stim required 1741.5 seconds, highlighting its consistent performance across different quantum error correction schemes. This streamlined approach makes it practical to identify noise hotspots and guide targeted improvements along the quantum circuit.

FaultScope can be used to benchmark large-scale quantum error correction schemes and guide targeted noise reduction efficiently, thereby facilitating the design and optimization of fault-tolerant quantum computing architectures. “FaultScope can be used to benchmark large-scale quantum error correction schemes and guide targeted noise reduction efficiently,” the researchers state, emphasizing the practical implications of their work.

Simulation Model: Clifford Circuits and Error Events

This unusual language pairing allows for both efficient computation and a user-friendly interface for researchers accustomed to Python’s data science ecosystem. The software’s core functionality centers on estimating logical error rates and, importantly, their derivatives with respect to component error rates from the same data set. The simulator’s performance was benchmarked against several established tools, including Stim, Aer, QuantumClifford and SymFT. In their noiseless and noisy benchmarks, FaultScope has the lowest runtime among the tested simulators at every size.

These summaries can be organized by qubit, gate, round, or operation, providing researchers with granular control over the analysis of noise sources. The software’s forward stabilizer simulation path, used for generating measurement records, was also used to measure the overhead associated with error attribution. Benchmarks reveal that computing all derivatives adds only 0.33-0.97% to the runtime of logical error rate estimation across five repetition code sizes with 7-2047 error locations.

More like this

Quantum Error CorrectionFramework Constructs Momentum States; Coupling Links Two Dimensions for Symmetry

Quantum Research NewsSWAPNET circuit boosts quantum state purity for near-term devices

Quantum HardwareMamba Model Reduces Qubit Error Rate 26%

Quantum Error CorrectionPreskill, Kubica & Hebrew University explore quantum error recovery