FaultScope software pinpoints errors in quantum error correction circuits

Introduction

Quantum error correction (QEC) is the linchpin of any scalable quantum computer, but optimizing QEC circuits is hampered by the need to run separate simulations for logical error rates and for sensitivity analysis. FaultScope, a new open‑source simulator developed by researchers at Tsinghua University and the Beijing Institute of Mathematical Sciences and Applications, tackles this bottleneck. Built in Rust for speed and wrapped in a Python API for ease of use, FaultScope delivers logical error‑rate estimates and the derivatives of those rates with respect to each noisy component in a single simulation run. The result is a compact “hotspot map” that tells engineers exactly where to focus noise‑reduction effort, all while adding less than one percent to overall runtime.

Simultaneous Error‑Rate and Sensitivity Estimation

Traditional workflows require two distinct stages: (1) Monte‑Carlo sampling to obtain a logical error rate, and (2) a second set of simulations—or a modified decoder—to compute how that rate changes when individual components are tweaked. FaultScope eliminates the second stage by recording event masks during the primary run and then applying a lightweight post‑processing step that computes the derivative of the logical error rate with respect to each component’s error probability. These derivatives, called sensitivities, quantify the impact of a single component on the overall logical failure probability. Because the same shot data serve both purposes, researchers obtain a full sensitivity profile without any extra decoding passes.

Two Simulation Pathways

FaultScope supports:

1. Forward simulation of Clifford circuits – Pauli errors are propagated through a compiled representation of ideal measurement relations, mirroring the way most stabilizer‑based QEC codes are analyzed.
2. Direct sampling from detector error models – The simulator bypasses circuit propagation entirely, generating detector outcomes directly from pre‑computed error signatures.

Both pathways store results in a compact binary format that can be fed straight into decoders, avoiding costly format conversions. Sensitivity summaries can be aggregated at any granularity—by qubit, gate, round, or whole operation—giving developers flexible insight into where errors originate.

Performance Highlights

In benchmark suites covering repetition codes (sizes 7–2047), surface‑code memories (distance up to 100), and lifted‑product codes, FaultScope consistently posted the lowest median runtime among six competing CPU simulators, including Stim, Aer, and SymFT. Notable figures include:

• Runtime overhead for full sensitivity calculation: 0.33 %–0.97 % of the base logical‑error‑rate estimation time.
• Speedup over Stim: up to 1.7× on random Clifford circuits with 1,024 qubits and 64 layers.
• Large‑scale success: completed a distance‑100 surface‑code simulation in ~2,043 s, where SymFT timed out at distance 30.

These gains stem from pre‑compiling measurement relations (or error signatures) and reusing them across shot batches, as well as from the efficient memory layout of event masks, which require only a few megabytes even for the largest codes tested.

Practical Impact: Targeted Noise Reduction

The sensitivity map produced by FaultScope enables a budget‑aware approach to hardware improvement. By ranking components according to their sensitivities, researchers can allocate limited mitigation resources—such as better calibration, improved gate design, or enhanced shielding—to the few “hotspots” that will most reduce the logical error rate. Simulations of surface‑code and lifted‑product circuits show that focusing on these hotspots yields a substantially larger logical‑error‑rate reduction than applying the same amount of effort randomly across the circuit.

Getting Started

FaultScope’s Python wrapper follows familiar scientific‑computing conventions: ```python import faultscope as fs sim = fs.Simulator(circuit, errormodel) result = sim.run(shots=100000, recordevents=True) print("Logical error rate:", result.logicalerrorrate) print("Top sensitivities:", result.sensitivities.topn(5)) ``` The core Rust library handles the heavy lifting, while the Python layer provides access to NumPy‑compatible data structures and integrates seamlessly with existing decoder pipelines.

Conclusion

FaultScope bridges a critical gap in QEC research by delivering logical error‑rate estimates and a full sensitivity analysis in a single, fast simulation run. Its hybrid Rust‑Python architecture offers both performance and accessibility, and its benchmark‑proven speed makes it practical for large‑scale code families. By turning raw error data into actionable hotspot maps, FaultScope equips quantum engineers with the information needed to prioritize hardware improvements and accelerate the path toward fault‑tolerant quantum computers.