Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2609.09334

Execution-transcript privacy for fault-tolerant surface-code memories

Jiachen Shen, Hui Zhong

quant-phcs.CRSubmitted Sep 8, 2026• Announced Sep 10, 2026• 0 citations
arXivHTMLPDF

Abstract

A fault-tolerant quantum computer runs behind a telemetry stream logging syndromes, decoder actions, resets and timing separately from the answer. Can it reveal the logical input? For a distance-$d$ rotated surface-code memory on a fixed schedule of $T=Θ(d)$ rounds, under three stated hypotheses (sector-scalar honest backbone, transcript locality, Kotecky-Preiss smallness), the channel from logical qubit to transcript is $e^{-Θ(d)}$-close in diamond norm to one that ignores the input. A statement of this kind follows generically from correctability-privacy duality. Anisotropy does not. Each logical axis pays the distance of its own coset, so under amplitude damping the computational-basis label is governed by the code's $Z$-distance $d_Z\ge d_{\min}$ and not by the code distance. Two codes of quantum distance $1$ make the gap concrete. A phase-flip code's $X$-syndrome transcript is exactly input-independent under unobserved damping, while a repetition code leaks at first order. A matched converse identifies the records that do expose it, among them a lattice-surgery parity readout. On a 156-qubit superconducting processor our sufficient certificate misses by $21.5\times$, so the theorem cannot be invoked there. Measured directly, a $d_Z=1$ memory's record identifies its input with total variation $\ge 0.927$ under randomised, label-balanced acquisition. Holding the code fixed and varying the damping exposure reproduces the parameter-free law, with exponent $0.85\pm0.03$ against a predicted $0.86$. Randomized encoding returns the statistic to the floor at no two-qubit-gate cost. Fault tolerance does not grant transcript privacy. It relocates it, and only to the logical state, not to the circuit's identity.

Comments
138 pages including appendices, 12 figures, 22 tables

Related papers

Demonstration of Logical Error Suppression in a Surface Code Memory on a Cloud-Accessible IBM Superconducting Processor

Shuwen Kan, Aaron Hoyt, Sean Garner +8 more

Quantum error correction can suppress logical errors exponentially with code distance when physical noise is below threshold. Realizing this on hardware requires tight coordination among quantum gates, mid-circuit measurements, and qubit coherence. Device variation, noise asymmetry, and correlations across space and time complicate the translation of these capabilities into logical error suppression. Here, we study rotated surface-code memory on an IBM Nighthawk r2 processor. Performance varies across tested processor placements, which we attribute to differences in qubit quality. We optimize the code by combining short readout, fused measurement and reset, and an XX echo on data qubits during ancilla readout. Compared with standard readout without reset or echo, the optimized syndrome extraction circuit reduces the median per-round logical error rate by factors of 3.8 in the X basis and 1.4 in the Z basis. In memory experiments of up to 150 rounds, the distance advantage weakens, alongside long-lived correlations that may reflect a persistent error component. Under our optimization recipe, increasing the protected distance from 3 to 6 while holding the other distance fixed reduces the per-round logical error rate from 0.53% to 0.24% in Z memory and from 0.52% to 0.22% in X memory. The corresponding error-suppression factors under maximum-likelihood decoding are 1.68 and 1.85. These results connect circuit compilation and optimization to surface-code memory performance and limitations, and motivate QPU and QEC circuit codesign for fault-tolerant quantum computing primitives on current cloud hardware.

quant-pharXiv:2610.23840•Oct 19, 2026•0 citations

High-threshold and low-overhead fault-tolerant quantum memory

Sergey B. Bravyi, Andrew W. Cross, Jay Gambetta +3 more

Abstract The accumulation of physical errors 1–3 prevents the execution of large-scale algorithms in current quantum computers. Quantum error correction 4 promises a solution by encoding k logical qubits onto a larger number n of physical qubits, such that the physical errors are suppressed enough to allow running a desired computation with tolerable fidelity. Quantum error correction becomes practically realizable once the physical error rate is below a threshold value that depends on the choice of quantum code, syndrome measurement circuit and decoding algorithm 5 . We present an end-to-end quantum error correction protocol that implements fault-tolerant memory on the basis of a family of low-density parity-check codes 6 . Our approach achieves an error threshold of 0.7% for the standard circuit-based noise model, on par with the surface code 7–10 that for 20 years was the leading code in terms of error threshold. The syndrome measurement cycle for a length- n code in our family requires n ancillary qubits and a depth-8 circuit with CNOT gates, qubit initializations and measurements. The required qubit connectivity is a degree-6 graph composed of two edge-disjoint planar subgraphs. In particular, we show that 12 logical qubits can be preserved for nearly 1 million syndrome cycles using 288 physical qubits in total, assuming the physical error rate of 0.1%, whereas the surface code would require nearly 3,000 physical qubits to achieve said performance. Our findings bring demonstrations of a low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.

arXiv:2308.07915•Nature•Mar 27, 2024•456 citations

What Must a Quantum-Memory Decoder Know About Temporally Correlated Noise?

Danesh Morales-Hashemi, Graeme Smith, Ningping Cao

What must a quantum error-correction decoder know about temporally correlated noise, and what does it cost to learn? We study this question for fixed stabilizer memory experiments with known system-environment interactions. We formulate calibration in terms of the fidelity differences that select a Pauli recovery and relate missing information to the resulting fidelity loss. Our main example uses weak coherent $X$ rotations in a class of CSS codes including Shor, Steane, and odd-distance rotated surface codes. All physical qubits share a sign either fixed throughout a run or independently redrawn each interval. The two models have identical syndrome statistics and the same spatiotemporal Pauli process (SPP), obtained by Pauli-twirling every noise interval. Yet at suitable storage times, they require different logical corrections. In the weak-noise limit, each model is almost perfectly correctable when known. Without model information, even the best final recovery has a worst-case fidelity loss approaching $1/2$ relative to the noise-aware optimum, despite access to the full syndrome record. For this pair of models, at fixed code and fixed positive target loss below $1/2$, we prove matching calibration bounds. With logical preparation and final readout, complete QEC cycles require a number of noise intervals scaling as the inverse rotation angle raised to the code's $X$ distance. Allowing two uninterrupted intervals before one extraction reduces the optimal cost to inverse-square scaling. Physical Pauli twirling of every noise interval changes both recovery performance and its information requirements. Discarding the record of applied random Pauli operations makes the SPP sufficient for optimal recovery. Keeping this record can improve the attainable fidelity, but reaching that optimum may require additional noise information.

quant-pharXiv:2610.03545•Oct 5, 2026•0 citations

Lower overhead fault-tolerant building blocks for noisy quantum computers

Prithviraj Prabhu

Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit. We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.

quant-pharXiv:2605.12385•May 13, 2026•0 citations

Novel Methods in Quantum Error Correction

Tomas Jochym-O’Connor

Quantum error correction is the backbone of fault-tolerant quantum computation, a necessary requirement for any large scale quantum computer. The fault-tolerance threshold theorem has long been a target for experimental precision, allowing for the possibility of reducing logical error rates to arbitrarily low levels without excessive overhead. While there are many promising fault-tolerant architectures, the path towards the most practical fault-tolerant scheme is far from decided and may vary for differing physical models. This thesis proposes new schemes for universal fault-tolerant quantum computation in both the concatenated and topological code settings. \n \nThrough the concatenation of two different error correcting codes, a set of universal fault-tolerant gates can be obtained without requiring the need for magic state distillation. A lower bound of $1.28 \\times 10^{-3}$ for the fault-tolerance threshold under circuit level depolarizing noise is obtained. Additionally, stacked codes are proposed as a means to simulate the action of a 3D topological code in 2D, allowing for the application of a universal set of transversal operations. While fault-tolerant, unfortunately the scheme does not exhibit a threshold due to the decreasing pseudo-threshold with growing code distance, yet points to potential interesting avenues for fault-tolerant computation in 2D without distillation. \n \nOne of the primary avenues to constructing fault-tolerant logical operations is through transversal operations. In this thesis, the set of single qubit logical gates that can be implemented transversally are characterized and determined to all belong to the Clifford hierarchy. Moreover, any diagonal two-qubit operation that can be applied transversally must belong to the same level of the Clifford hierarchy as the set of gates that can be implemented in the single-qubit case. \n \nThe opposite to quantum error correction is privacy, where the output of a channel is disguised from its input. The two are fundamentally related through the complementary channel construction. This thesis presents a new class of private quantum channels, expanding the existing class beyond a seemingly fundamental restriction. This yields interesting insights into the structure of quantum information and the leaking of information to external environments. Additionally, the duality is only recovered when extending the complementary channel to sufficiently high environmental dimension. \n \nFinally, the error properties of bucket brigade quantum Random Access Memory (qRAM) are assessed. It is determined that using the bucket brigade qRAM architecture for the running of Grover's algorithm necessitates reducing the error rate of the individual components to exponentially small levels for an exponential sized memory. As such, fault-tolerant architectures will likely play an essential role in the construction of such computing primitives.

•Aug 24, 2016•0 citations

Where magic-state cultivation pays in early fault-tolerant quantum computing: a single-clock cost model of logical error mitigation and magic-state supply

Hikaru Wakaura, Taiki Tanimae

Abstract Error-corrected quantum computers limited to small code distances trade physical qubits against the number of logical operations they can run. Two tools set that trade-off in the early fault-tolerant era: logical-level error mitigation, which cancels residual logical errors at a sampling cost exponential in the total error, and magic-state cultivation, which prepares non-Clifford resource states far more cheaply than distillation. Their resource estimates use different accountings of time, idle error, and consumption, so their combination has not been costed consistently. Here we build one cost model in which data block, factory, and sampling overhead share one clock and precision target, and show that whether cultivation pays is decided by two architectural numbers: the $T$-state demand per time step, $\rho=n_L u f_T$, which sets the factory area, and the exposure $N/u$, which sets the idle error, where $u$ is the fraction of the $n_L$ logical qubits acted on per step and $f_T$ the $T$ fraction. At $\rho\approx1$ adding cultivation to error mitigation saves $6$--$9\%$ of physical qubits; at $\rho\approx30$ it saves $71$--$85\%$ because factories dominate the footprint. The feasible circuit size grows by at most $1.8$--$2.7\times$ and never reaches $10^{10}$ operations at $d\le13$. We also identify a storage-limited error floor for 15-to-1 distillation confined to patch distance $d_X\le11$ ($3.7\times10^{-6}$ at error rate $10^{-3}$), compute the exact floor of the $d_1=3$ cultivation stage ($6.8\times10^{-7}$), show that escaping to $d_2=7$--$11$ costs $25$--$56\%$ of the published volume, and find that the error of a cultivated state given its decoder gap follows one curve per $d_1$ to within $2\times$. On reported logical error suppression factors, today's hardware supports only tens of mitigated logical operations; the regime opens below a physical error rate of $2\times10^{-3}$.

•Oct 5, 2026•0 citations
A fault-tolerant quantum computer runs behind a telemetry stream logging syndromes, decoder actions, resets and timing separately from the answer. Can it reveal the logical input? For a distance-ddd rotated surface-code memory on a fixed schedule of T=Θ(d)T=Θ(d)T=Θ(d) rounds, under three stated hypotheses (sector-scalar honest backbone, transcript locality, Kotecky-Preiss smallness), the channel from logical qubit to transcript is e−Θ(d)e^{-Θ(d)}e−Θ(d)-close in diamond norm to one that ignores the input. A statement of this kind follows generically from correctability-privacy duality. Anisotropy does not. Each logical axis pays the distance of its own coset, so under amplitude damping the computational-basis label is governed by the code's ZZZ-distance dZ≥dmin⁡d_Z\ge d_{\min}dZ​≥dmin​ and not by the code distance. Two codes of quantum distance 111 make the gap concrete. A phase-flip code's XXX-syndrome transcript is exactly input-independent under unobserved damping, while a repetition code leaks at first order. A matched converse identifies the records that do expose it, among them a lattice-surgery parity readout. On a 156-qubit superconducting processor our sufficient certificate misses by 21.5×21.5\times21.5×, so the theorem cannot be invoked there. Measured directly, a dZ=1d_Z=1dZ​=1 memory's record identifies its input with total variation ≥0.927\ge 0.927≥0.927 under randomised, label-balanced acquisition. Holding the code fixed and varying the damping exposure reproduces the parameter-free law, with exponent 0.85±0.030.85\pm0.030.85±0.03 against a predicted 0.860.860.86. Randomized encoding returns the statistic to the floor at no two-qubit-gate cost. Fault tolerance does not grant transcript privacy. It relocates it, and only to the logical state, not to the circuit's identity.
Quantum error correction can suppress logical errors exponentially with code distance when physical noise is below threshold. Realizing this on hardware requires tight coordination among quantum gates, mid-circuit measurements, and qubit coherence. Device variation, noise asymmetry, and correlations across space and time complicate the translation of these capabilities into logical error suppression. Here, we study rotated surface-code memory on an IBM Nighthawk r2 processor. Performance varies across tested processor placements, which we attribute to differences in qubit quality. We optimize the code by combining short readout, fused measurement and reset, and an XX echo on data qubits during ancilla readout. Compared with standard readout without reset or echo, the optimized syndrome extraction circuit reduces the median per-round logical error rate by factors of 3.8 in the X basis and 1.4 in the Z basis. In memory experiments of up to 150 rounds, the distance advantage weakens, alongside long-lived correlations that may reflect a persistent error component. Under our optimization recipe, increasing the protected distance from 3 to 6 while holding the other distance fixed reduces the per-round logical error rate from 0.53% to 0.24% in Z memory and from 0.52% to 0.22% in X memory. The corresponding error-suppression factors under maximum-likelihood decoding are 1.68 and 1.85. These results connect circuit compilation and optimization to surface-code memory performance and limitations, and motivate QPU and QEC circuit codesign for fault-tolerant quantum computing primitives on current cloud hardware.
Abstract The accumulation of physical errors 1–3 prevents the execution of large-scale algorithms in current quantum computers. Quantum error correction 4 promises a solution by encoding k logical qubits onto a larger number n of physical qubits, such that the physical errors are suppressed enough to allow running a desired computation with tolerable fidelity. Quantum error correction becomes practically realizable once the physical error rate is below a threshold value that depends on the choice of quantum code, syndrome measurement circuit and decoding algorithm 5 . We present an end-to-end quantum error correction protocol that implements fault-tolerant memory on the basis of a family of low-density parity-check codes 6 . Our approach achieves an error threshold of 0.7% for the standard circuit-based noise model, on par with the surface code 7–10 that for 20 years was the leading code in terms of error threshold. The syndrome measurement cycle for a length- n code in our family requires n ancillary qubits and a depth-8 circuit with CNOT gates, qubit initializations and measurements. The required qubit connectivity is a degree-6 graph composed of two edge-disjoint planar subgraphs. In particular, we show that 12 logical qubits can be preserved for nearly 1 million syndrome cycles using 288 physical qubits in total, assuming the physical error rate of 0.1%, whereas the surface code would require nearly 3,000 physical qubits to achieve said performance. Our findings bring demonstrations of a low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.
What must a quantum error-correction decoder know about temporally correlated noise, and what does it cost to learn? We study this question for fixed stabilizer memory experiments with known system-environment interactions. We formulate calibration in terms of the fidelity differences that select a Pauli recovery and relate missing information to the resulting fidelity loss. Our main example uses weak coherent XXX rotations in a class of CSS codes including Shor, Steane, and odd-distance rotated surface codes. All physical qubits share a sign either fixed throughout a run or independently redrawn each interval. The two models have identical syndrome statistics and the same spatiotemporal Pauli process (SPP), obtained by Pauli-twirling every noise interval. Yet at suitable storage times, they require different logical corrections. In the weak-noise limit, each model is almost perfectly correctable when known. Without model information, even the best final recovery has a worst-case fidelity loss approaching 1/21/21/2 relative to the noise-aware optimum, despite access to the full syndrome record. For this pair of models, at fixed code and fixed positive target loss below 1/21/21/2, we prove matching calibration bounds. With logical preparation and final readout, complete QEC cycles require a number of noise intervals scaling as the inverse rotation angle raised to the code's XXX distance. Allowing two uninterrupted intervals before one extraction reduces the optimal cost to inverse-square scaling. Physical Pauli twirling of every noise interval changes both recovery performance and its information requirements. Discarding the record of applied random Pauli operations makes the SPP sufficient for optimal recovery. Keeping this record can improve the attainable fidelity, but reaching that optimum may require additional noise information.
Quantum computation holds the promise of solving certain complex problems exponentially faster than classical computers. However, the high prevalent noise in current quantum devices impedes the accurate execution of even basic algorithms. This can be remedied by protecting quantum information with a quantum error-correcting code, where the logical information of an algorithmic qubit is spread across multiple physical qubits. Individual quantum errors are then located and corrected by the fault-tolerant measurement of multi-qubit stabilizer operators (parity checks). Unfortunately, error correction and fault tolerance both impose large demands on the qubit overhead: hundreds to thousands of physical qubits per logical qubit. We reduce the spacetime cost of fault tolerance by redesigning key building blocks of an error-corrected quantum computer. First, we develop a combinatorial proof with flag fault tolerance that exponentially reduces the extra qubits needed to measure a stabilizer of any size, while tolerating one fault. We leverage these proofs to then design state preparation circuits for the Steane and Golay codes with 100% yield. Next, we improve error correction on a planar layout by showing that a distance-four code encoding six logical qubits protects information as well as the distance-five surface code, using one-tenth as many physical qubits. Finally, we optimize the time overhead of logical gates in surface code quantum computers by protecting measurement results with a classical code, cutting computation time by a factor of two to six. Our hardware-agnostic optimizations of fault tolerance overheads thus suggest new routes to advance the timeline of error-free quantum computing.
Quantum error correction is the backbone of fault-tolerant quantum computation, a necessary requirement for any large scale quantum computer. The fault-tolerance threshold theorem has long been a target for experimental precision, allowing for the possibility of reducing logical error rates to arbitrarily low levels without excessive overhead. While there are many promising fault-tolerant architectures, the path towards the most practical fault-tolerant scheme is far from decided and may vary for differing physical models. This thesis proposes new schemes for universal fault-tolerant quantum computation in both the concatenated and topological code settings. \n \nThrough the concatenation of two different error correcting codes, a set of universal fault-tolerant gates can be obtained without requiring the need for magic state distillation. A lower bound of 1.28times10−31.28 \\times 10^{-3}1.28times10−3 for the fault-tolerance threshold under circuit level depolarizing noise is obtained. Additionally, stacked codes are proposed as a means to simulate the action of a 3D topological code in 2D, allowing for the application of a universal set of transversal operations. While fault-tolerant, unfortunately the scheme does not exhibit a threshold due to the decreasing pseudo-threshold with growing code distance, yet points to potential interesting avenues for fault-tolerant computation in 2D without distillation. \n \nOne of the primary avenues to constructing fault-tolerant logical operations is through transversal operations. In this thesis, the set of single qubit logical gates that can be implemented transversally are characterized and determined to all belong to the Clifford hierarchy. Moreover, any diagonal two-qubit operation that can be applied transversally must belong to the same level of the Clifford hierarchy as the set of gates that can be implemented in the single-qubit case. \n \nThe opposite to quantum error correction is privacy, where the output of a channel is disguised from its input. The two are fundamentally related through the complementary channel construction. This thesis presents a new class of private quantum channels, expanding the existing class beyond a seemingly fundamental restriction. This yields interesting insights into the structure of quantum information and the leaking of information to external environments. Additionally, the duality is only recovered when extending the complementary channel to sufficiently high environmental dimension. \n \nFinally, the error properties of bucket brigade quantum Random Access Memory (qRAM) are assessed. It is determined that using the bucket brigade qRAM architecture for the running of Grover's algorithm necessitates reducing the error rate of the individual components to exponentially small levels for an exponential sized memory. As such, fault-tolerant architectures will likely play an essential role in the construction of such computing primitives.
Abstract Error-corrected quantum computers limited to small code distances trade physical qubits against the number of logical operations they can run. Two tools set that trade-off in the early fault-tolerant era: logical-level error mitigation, which cancels residual logical errors at a sampling cost exponential in the total error, and magic-state cultivation, which prepares non-Clifford resource states far more cheaply than distillation. Their resource estimates use different accountings of time, idle error, and consumption, so their combination has not been costed consistently. Here we build one cost model in which data block, factory, and sampling overhead share one clock and precision target, and show that whether cultivation pays is decided by two architectural numbers: the TTT-state demand per time step, ρ=nLufT\rho=n_L u f_Tρ=nL​ufT​, which sets the factory area, and the exposure N/uN/uN/u, which sets the idle error, where uuu is the fraction of the nLn_LnL​ logical qubits acted on per step and fTf_TfT​ the TTT fraction. At ρ≈1\rho\approx1ρ≈1 adding cultivation to error mitigation saves 666--9%9\%9% of physical qubits; at ρ≈30\rho\approx30ρ≈30 it saves 717171--85%85\%85% because factories dominate the footprint. The feasible circuit size grows by at most 1.81.81.8--2.7×2.7\times2.7× and never reaches 101010^{10}1010 operations at d≤13d\le13d≤13. We also identify a storage-limited error floor for 15-to-1 distillation confined to patch distance dX≤11d_X\le11dX​≤11 (3.7×10−63.7\times10^{-6}3.7×10−6 at error rate 10−310^{-3}10−3), compute the exact floor of the d1=3d_1=3d1​=3 cultivation stage (6.8×10−76.8\times10^{-7}6.8×10−7), show that escaping to d2=7d_2=7d2​=7--111111 costs 252525--56%56\%56% of the published volume, and find that the error of a cultivated state given its decoder gap follows one curve per d1d_1d1​ to within 2×2\times2×. On reported logical error suppression factors, today's hardware supports only tens of mitigated logical operations; the regime opens below a physical error rate of 2×10−32\times10^{-3}2×10−3.