[Paper Review] How to choose a decoder for a fault-tolerant quantum computer? The speed vs accuracy trade-off

Nicolas Delfosse, Andres Paz+2 more|arXiv (Cornell University)|Oct 23, 2023

Quantum Computing Algorithms and Architecture4 citations

TL;DR

This paper proposes a framework to select optimal decoders for fault-tolerant quantum computers by balancing decoding speed and accuracy, using spacetime cost as a metric. It introduces a protocol to optimize decoder stopping time, showing that PyMatching on a desktop machine can handle thousands of logical T gates but may be too slow for 10⁵ gates due to decoding delays, highlighting the need for hardware-optimized decoders.

ABSTRACT

Achieving practical quantum advantage requires a classical decoding algorithm to identify and correct faults during computation. This classical decoding algorithm must deliver both accuracy and speed, but in what combination? When is a decoder "fast enough" or "accurate enough"? In the case of surface codes, tens of decoding algorithms have been proposed, with different accuracies and speeds. However, it has been unclear how to choose the best decoder for a given quantum architecture. Should a faster decoder be used at the price of reduced accuracy? Or should a decoder sacrifice accuracy to fit within a given time constraint? If a decoder is too slow, it may be stopped upon reaching a time bound, at the price of some time-out failures and an increased failure rate. What then is the optimal stopping time of the decoder? By analyzing the speed vs. accuracy tradeoff, we propose strategies to select the optimal stopping time for a decoder for different tasks. We design a protocol to select the decoder that minimizes the spacetime cost per logical gate, for logical computation of a given depth. Our protocol enables comparison of different decoders, and the selection of an appropriate decoder for a given fault-tolerant quantum computing architecture. We illustrate our protocol for the surface code equipped with a desktop implementation of the PyMatching decoder. We estimate PyMatching is fast enough to implement thousands of logical gates with a better accuracy than physical qubits. However, we find it is not sufficiently fast to reach 10^5 logical gates, under certain assumptions, due to the decoding delay which forces qubits to idle and accumulate errors while idling. We expect further improvements to PyMatching are possible by running it on a better machine or by reducing the OS interference.

Motivation & Objective

• To address the open question of how to choose a decoder for fault-tolerant quantum computing architectures.
• To develop a systematic method for selecting decoders that minimizes spacetime cost per logical gate.
• To analyze the impact of decoding delay on logical error rates and resource overhead.
• To evaluate the performance of existing decoders, such as PyMatching, under realistic hardware constraints.
• To guide co-design of classical decoding algorithms and quantum hardware for scalable quantum advantage.

Proposed method

• The authors define a spacetime cost metric that accounts for decoding delay and logical failure rates.
• They model the trade-off between decoder speed and accuracy using a time-bound decoding strategy with a configurable stopping time.
• The protocol compares decoders by simulating their performance across different logical gate depths and physical error rates.
• They apply the framework to surface codes with a 1 μs syndrome extraction time and p = 10⁻³ physical error rate.
• They evaluate PyMatching on a desktop machine to estimate real-world decoding performance and identify bottlenecks like OS interference.
• They use numerical simulations to compare linear-time, quadratic-time, and instantaneous decoders under varying logical gate counts.

Figure 1: State injection circuit for the implementation of a $T$ gate. Assume that we can prepare a $T$ state $|{T}\rangle=\frac{1}{\sqrt{2}}(|{0}\rangle+e^{i\pi/4}|{1}\rangle)$ on the bottom qubit. Then, we can apply a $T$ gate on the top qubit using only Clifford operations. The gate $S$ is appli

Experimental results

Research questions

• RQ1 What is the optimal stopping time for a decoder to minimize spacetime cost in fault-tolerant quantum computation?
• RQ2 How does decoding delay affect the logical error rate and resource cost in surface code architectures?
• RQ3 Which decoder offers the best trade-off between speed and accuracy for a given number of logical T gates?
• RQ4 Can existing decoding software like PyMatching scale to large-scale quantum computation under realistic hardware constraints?
• RQ5 How do hardware-level factors such as OS interference and computational architecture impact decoder performance?

Key findings

• PyMatching running on a desktop machine can decode thousands of logical T gates with lower error rates than physical qubits, demonstrating practical feasibility for moderate-scale computations.
• For logical gate counts exceeding 10⁵, PyMatching's decoding delay becomes a limiting factor, increasing the logical failure rate due to idle qubit error accumulation.
• The linear-time decoder has a spacetime cost up to 4× higher than the quadratic-time decoder for small gate counts, but becomes 80% cheaper for large-scale computations.
• The optimal decoder depends non-monotonically on the number of logical T gates, making decoder selection highly context-dependent.
• Runtime variability in PyMatching is significantly affected by operating system interference, suggesting that dedicated hardware could improve stability and performance.
• Future improvements via hardware acceleration (e.g., FPGA or ASIC) or pre-decoding techniques (e.g., BP or lazy decoding) could reduce decoding delays and enable larger-scale fault-tolerant computation.

Figure 2: (a) Runtime distribution of PyMatching estimated using $10^{9}$ decoding trials for a distance-29 surface code with $d$ rounds of syndrome extraction on a desktop computer with an Intel Xeon CPU E5-2620 v4 @2.1Ghz processor with 64Gb of memory. We use Stim [ 23 ] to sample circuit faults a