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:2610.16401

Magic-Free Certification of Logical Error Rates in Universal Fault-Tolerant Circuits

Gebrat Porta-San Miguel, Shahram Panahiyan, Dieter Jaksch

quant-phSubmitted Oct 12, 2026• Announced Oct 13, 2026• 0 citations
arXivHTMLPDF

Abstract

As quantum hardware enters the fault-tolerant regime, algorithms are beginning to be executed on encoded qubits, yet scalable certification of how well they run remains an open problem. Here we introduce magic-free certification, a certification protocol for universal fault-tolerant circuits that consumes no magic, the resource that generally places them beyond efficient classical simulation and is by far the most expensive element of a fault-tolerant computation. The protocol is code- and decoder-agnostic, runs interleaved with the target circuit on the same device, and has a sample complexity that grows linearly with the number of logical qubits and non-Clifford gates while remaining decoupled from the logical error rate itself. Given a predefined error tolerance $p_L^*$, the protocol determines at a chosen confidence level whether the device executes the target circuit at a logical error rate below $p_L^*$. The method relies on trap circuits, copies of the target with every magic state replaced by a stabilizer state, whose outcomes are deterministic and which, being indistinguishable from the target to stochastic Pauli noise, fail at the same rate. We illustrate the protocol in Steane-code simulations of a magic state injection gadget and a quantum Fourier transform.

AI Summary

The paper addresses certification of universal fault-tolerant circuits without classically computing their ideal outputs or consuming additional magic states. It constructs stabilizer-only trap circuits by replacing injected magic states with stabilizer states and sampling the injection corrections. Each trap prepares an input giving a deterministic logical Pauli measurement, so a flipped outcome directly detects an error. For $k_D$ data qubits and $k_T$ injections, the construction uses $3K$ measurement configurations, where $K=k_D+k_T$ counts injection ancillas even when hardware is reused. Pauli propagation, the fact that each nonidentity single-qubit Pauli anticommutes with two measurement axes, and a union bound give $p_L\leq\bar p_L=\frac12\sum_{i=1}^{3K}p(\mathcal T_i)$. A hypothesis test on pooled trap failures certifies a prescribed tolerance $p_L^*$, with shot scaling $O(K/p_L^*)$ for fixed confidence and acceptance margin. The budget is independent of the actual logical error rate, but diverges quadratically as the margin closes. Steane-code simulations illustrate a single injection gadget and a two-data-qubit QFT with three injections. For the latter, tolerance $10^{-5}$, 5% false-positive probability, and 90% acceptance probability at half the tolerance require approximately $1.9\times10^7$ shots. The guarantees assume Markovian stochastic Pauli noise, basis-independent preparation noise, a fixed decoder, and independently characterized magic states no noisier than their trap substitutes. Correlated executions can invalidate statistical confidence; Poisson calibration is approximate. The bound overcounts correlated and output-harmless errors. Residual coherent noise requires an independently characterized additive correction. No hardware demonstration is reported.

Little sign of AI-generated textStrong assumptionsOverclaimsPossible errorMissing comparison

Central claim may not hold: The abstract claims equal target and trap failure rates, whereas the body establishes only an aggregate upper bound that can overcount errors and include errors harmless to the target. The advertised certificate requires assumptions beyond stochastic Pauli noise and excludes independent certification of the magic-state supply. The central theorem is false under A2 as written because a larger stabilizer-resource preparation error rate can cancel subsequent faults in the traps without canceling them in the target.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
21 pages, 3 figures

Related papers

Exact efficient simulation of noisy logical magic states using Clifford stabilizers

Yugo Takada, Stephen D. Bartlett, Dominic J. Williamson

The preparation of high-fidelity logical magic states is a crucial subroutine for universal fault-tolerant quantum computation (FTQC). Predicting the performance of FTQC and developing improved protocols rely on numerical methods to classically simulate logical magic state preparation in the presence of noise. Clifford logic on Pauli-stabilizer codes with circuit-level Pauli errors can be efficiently simulated using Pauli-stabilizer formalism, but the non-Clifford operations required to prepare logical magic states render generic simulation inefficient. We introduce Clifford-stabilizer simulation, an exact and efficient algorithm based on updating a Clifford-stabilizer group to simulate noisy preparation protocols for a broad class of logical magic states used to implement non-Clifford gates in the third level of the Clifford hierarchy under circuit-level Pauli errors. Clifford-stabilizer simulation applies to a range of operations that commonly appear in preparation protocols for such logical magic states, including Pauli-stabilizer measurements, logical Clifford measurements, and transversal non-Clifford gates. Our algorithm for Clifford-stabilizer simulation maps a non-Clifford circuit with sampled circuit-level Pauli errors to a Clifford circuit that exactly reproduces its measurement outcome distribution, achieving time and space complexities polynomial in relevant protocol parameters. We perform exact simulation of magic state cultivation up to fault distance 7 by Clifford-stabilizer simulation. Our method provides a route to perform exact benchmarking of large-scale logical magic state preparation protocols required for useful FTQC.

quant-pharXiv:2609.16929•Sep 16, 2026•10 citations

Breaking even with magic: demonstration of a high-fidelity logical non-Clifford gate

Shival Dasu, Burton, Simon, Karl Mayer +7 more

Encoding quantum information to protect it from errors is essential for performing large-scale quantum computations. Performing a universal set of quantum gates on encoded states demands a potentially large resource overhead and minimizing this overhead is key for the practical development of large-scale fault-tolerant quantum computers. We propose and experimentally implement a magic-state preparation protocol to fault-tolerantly prepare a pair of logical magic states in a [[6,2,2]] quantum error-detecting code using only eight physical qubits. Implementing this protocol on H1-1, a 20 qubit trapped-ion quantum processor, we prepare magic states with experimental infidelity $7^{+3}_{-1}\times 10^{-5}$ with a $14.8^{+1}_{-1}\%$ discard rate and use these to perform a fault-tolerant non-Clifford gate, the controlled-Hadamard (CH), with logical infidelity $\leq 2.3^{+9}_{-9}\times 10^{-4}$. Notably, this significantly outperforms the unencoded physical CH infidelity of $10^{-3}$. Through circuit-level stabilizer simulations, we show that this protocol can be self-concatenated to produce extremely high-fidelity magic states with low space-time overhead in a [[36,4,4]] quantum error correcting code, with logical error rates of $6\times 10^{-10}$ ($5\times 10^{-14}$) at two-qubit error rate of $10^{-3}$ ($10^{-4}$) respectively.

arXiv:2506.14688•Jun 17, 2025•51 citations

Efficient simulation of logical magic state preparation protocols

Samyak Surti, Lucas Daguerre, Isaac H. Kim

Developing space- and time-efficient logical magic state preparation protocols will likely be an essential step towards building a large-scale fault-tolerant quantum computer. Motivated by this need, we introduce a scalable method for simulating logical magic state preparation protocols under the standard circuit-level noise model. When applied to protocols based on code switching, magic state cultivation, and magic state distillation, our method yields a complexity polynomial in (i) the number of qubits and (ii) the non-stabilizerness, e.g., stabilizer rank or Pauli rank, of the target encoded magic state. The efficiency of our simulation method is rooted in a curious fact: every circuit-level Pauli error in these protocols propagates to a Clifford error at the end. This property is satisfied by a large family of protocols, including those that repeatedly measure a transversal Clifford that squares to a Pauli. We provide a proof-of-principle numerical simulation that prepares a magic state using such logical Clifford measurements. Our work enables practical simulation of logical magic state preparation protocols without resorting to approximations or resource-intensive state-vector simulations.

quant-pharXiv:2512.23799•PRX Quantum•Dec 31, 2025•13 citations

Extremely Low-Cost Magic State Preparation toward Fault-Tolerant Quantum Computing

Jianshuo Gao, Xiao Yuan, Yuan Yao

Fault-tolerant preparation of non-Clifford resource states is a major contributor to the overhead of quantum computation, motivating protocols that achieve high output fidelity with minimal qubit and circuit costs. We introduce a low-cost magic-state preparation protocol in which the choice of stabilizer generators is co-designed with the flag gadgets, allowing the syndrome-extraction circuit itself to filter correlated faults across a non-Clifford layer. The protocol prepares a logical plus state in the 15-qubit quantum Reed-Muller code, applies a transversal T gate, and gauge-fixes the same register into the seven-qubit Steane code. By reorganizing equivalent Z-type stabilizer generators into jointly flagged measurement groups, the protocol eliminates all accepted logical-error contributions arising from one or two circuit faults under destructive error detection. Under a uniform circuit-level depolarizing noise model, the postselected infidelity is $210.2p^3+O(p^4)$. At $p=10^{-3}$, exact low-order enumeration combined with stratified sampling bounds the infidelity by $2.2\times10^{-7}$ at 99.9% joint confidence, while retaining an acceptance probability of 86.9%. The complete circuit requires only 19 qubits and 82 CNOT gates. These results demonstrate that stabilizer-generator design can substantially reduce the cost of postselected magic-state preparation, although corrected operation and the fidelity of an unmeasured output block require separate analysis.

quant-pharXiv:2609.12698•Sep 14, 2026•0 citations

In-situ benchmarking of fault-tolerant quantum circuits. I. Clifford circuits

Xiao Xiao, Dominik Hangleiter, Dolev Bluvstein +2 more

Benchmarking physical devices and verifying logical algorithms are important tasks for scalable fault-tolerant quantum computing. Numerous protocols exist for benchmarking devices before running actual algorithms. In this work, we show that both physical and logical errors of fault-tolerant circuits can even be characterized in-situ using syndrome data. To achieve this, we map general fault-tolerant Clifford circuits to subsystem codes using the spacetime code formalism and develop a scheme for estimating Pauli noise in Clifford circuits using syndrome data. We give necessary and sufficient conditions for the learnability of physical and logical noise from given syndrome data, and show that we can accurately predict logical fidelities from the same data. Importantly, our approach requires only a polynomial sample size, even when the logical error rate is exponentially suppressed by the code distance, and thus gives an exponential advantage against methods that use only logical data such as direct fidelity estimation. We demonstrate the practical applicability of our methods in various scenarios using synthetic data as well as the experimental data from a recent demonstration of fault-tolerant circuits by Bluvstein et al. [Nature 626, 7997 (2024)]. Our methods provide an efficient, in-situ way of characterizing a fault-tolerant quantum computer to help gate calibration, improve decoding accuracy, and verify logical circuits.

quant-pharXiv:2601.21472•PRX Quantum•Jan 30, 2026•11 citations

Fault-tolerant $|\sqrt{ \mathrm{T} }\rangle$ state preparation and injection for more efficient fine-grained quantum circuit synthesis

Berat Yenilen, Markus Müller, Manuel Rispler

Magic-state injection is a standard route to realize universal fault-tolerant quantum computation. Whereas the set of Clifford gates in combination with the non-Clifford T gate is a widely used universal gate set, extending the available set of non-Clifford primitives can reduce compilation overhead, provided that the additional primitives can be prepared fault-tolerantly with competitive resource costs and at sufficiently low logical noise rates. In this work, we introduce flag fault-tolerant protocols for preparing logical $|\sqrt{\mathrm{T}} \rangle $ magic states on the 3D tetrahedral color code and its smaller morphed variant. Our simulations under circuit-level noise verify fault tolerance, quantify acceptance and logical error rates, and we reconstruct the effective logical channels of the corresponding circuits for gate injection via logical process tomography. We find that access to $\sqrt{\mathrm{T}}$ reduces the average space-time cost of synthesizing Haar-random single-qubit unitaries by approximately $20$-$30$% relative to the Clifford+T gate set across practically relevant approximation regimes. These results demonstrate how expanding the set of fault-tolerant non-Clifford primitives can improve computational efficiency and broaden the design space for universal quantum computation in the early fault-tolerant era.

quant-pharXiv:2608.25797•Aug 27, 2026•1 citation
As quantum hardware enters the fault-tolerant regime, algorithms are beginning to be executed on encoded qubits, yet scalable certification of how well they run remains an open problem. Here we introduce magic-free certification, a certification protocol for universal fault-tolerant circuits that consumes no magic, the resource that generally places them beyond efficient classical simulation and is by far the most expensive element of a fault-tolerant computation. The protocol is code- and decoder-agnostic, runs interleaved with the target circuit on the same device, and has a sample complexity that grows linearly with the number of logical qubits and non-Clifford gates while remaining decoupled from the logical error rate itself. Given a predefined error tolerance pL∗p_L^*pL∗​, the protocol determines at a chosen confidence level whether the device executes the target circuit at a logical error rate below pL∗p_L^*pL∗​. The method relies on trap circuits, copies of the target with every magic state replaced by a stabilizer state, whose outcomes are deterministic and which, being indistinguishable from the target to stochastic Pauli noise, fail at the same rate. We illustrate the protocol in Steane-code simulations of a magic state injection gadget and a quantum Fourier transform.
The paper addresses certification of universal fault-tolerant circuits without classically computing their ideal outputs or consuming additional magic states. It constructs stabilizer-only trap circuits by replacing injected magic states with stabilizer states and sampling the injection corrections. Each trap prepares an input giving a deterministic logical Pauli measurement, so a flipped outcome directly detects an error.
For kDk_DkD​ data qubits and kTk_TkT​ injections, the construction uses 3K3K3K measurement configurations, where K=kD+kTK=k_D+k_TK=kD​+kT​ counts injection ancillas even when hardware is reused. Pauli propagation, the fact that each nonidentity single-qubit Pauli anticommutes with two measurement axes, and a union bound give pL≤pˉL=12∑i=13Kp(Ti)p_L\leq\bar p_L=\frac12\sum_{i=1}^{3K}p(\mathcal T_i)pL​≤pˉ​L​=21​∑i=13K​p(Ti​). A hypothesis test on pooled trap failures certifies a prescribed tolerance pL∗p_L^*pL∗​, with shot scaling O(K/pL∗)O(K/p_L^*)O(K/pL∗​) for fixed confidence and acceptance margin. The budget is independent of the actual logical error rate, but diverges quadratically as the margin closes. Steane-code simulations illustrate a single injection gadget and a two-data-qubit QFT with three injections. For the latter, tolerance 10−510^{-5}10−5, 5% false-positive probability, and 90% acceptance probability at half the tolerance require approximately 1.9×1071.9\times10^71.9×107 shots.
The guarantees assume Markovian stochastic Pauli noise, basis-independent preparation noise, a fixed decoder, and independently characterized magic states no noisier than their trap substitutes. Correlated executions can invalidate statistical confidence; Poisson calibration is approximate. The bound overcounts correlated and output-harmless errors. Residual coherent noise requires an independently characterized additive correction. No hardware demonstration is reported.
The preparation of high-fidelity logical magic states is a crucial subroutine for universal fault-tolerant quantum computation (FTQC). Predicting the performance of FTQC and developing improved protocols rely on numerical methods to classically simulate logical magic state preparation in the presence of noise. Clifford logic on Pauli-stabilizer codes with circuit-level Pauli errors can be efficiently simulated using Pauli-stabilizer formalism, but the non-Clifford operations required to prepare logical magic states render generic simulation inefficient. We introduce Clifford-stabilizer simulation, an exact and efficient algorithm based on updating a Clifford-stabilizer group to simulate noisy preparation protocols for a broad class of logical magic states used to implement non-Clifford gates in the third level of the Clifford hierarchy under circuit-level Pauli errors. Clifford-stabilizer simulation applies to a range of operations that commonly appear in preparation protocols for such logical magic states, including Pauli-stabilizer measurements, logical Clifford measurements, and transversal non-Clifford gates. Our algorithm for Clifford-stabilizer simulation maps a non-Clifford circuit with sampled circuit-level Pauli errors to a Clifford circuit that exactly reproduces its measurement outcome distribution, achieving time and space complexities polynomial in relevant protocol parameters. We perform exact simulation of magic state cultivation up to fault distance 7 by Clifford-stabilizer simulation. Our method provides a route to perform exact benchmarking of large-scale logical magic state preparation protocols required for useful FTQC.
Encoding quantum information to protect it from errors is essential for performing large-scale quantum computations. Performing a universal set of quantum gates on encoded states demands a potentially large resource overhead and minimizing this overhead is key for the practical development of large-scale fault-tolerant quantum computers. We propose and experimentally implement a magic-state preparation protocol to fault-tolerantly prepare a pair of logical magic states in a [[6,2,2]] quantum error-detecting code using only eight physical qubits. Implementing this protocol on H1-1, a 20 qubit trapped-ion quantum processor, we prepare magic states with experimental infidelity 7−1+3×10−57^{+3}_{-1}\times 10^{-5}7−1+3​×10−5 with a 14.8−1+1%14.8^{+1}_{-1}\%14.8−1+1​% discard rate and use these to perform a fault-tolerant non-Clifford gate, the controlled-Hadamard (CH), with logical infidelity ≤2.3−9+9×10−4\leq 2.3^{+9}_{-9}\times 10^{-4}≤2.3−9+9​×10−4. Notably, this significantly outperforms the unencoded physical CH infidelity of 10−310^{-3}10−3. Through circuit-level stabilizer simulations, we show that this protocol can be self-concatenated to produce extremely high-fidelity magic states with low space-time overhead in a [[36,4,4]] quantum error correcting code, with logical error rates of 6×10−106\times 10^{-10}6×10−10 (5×10−145\times 10^{-14}5×10−14) at two-qubit error rate of 10−310^{-3}10−3 (10−410^{-4}10−4) respectively.
Developing space- and time-efficient logical magic state preparation protocols will likely be an essential step towards building a large-scale fault-tolerant quantum computer. Motivated by this need, we introduce a scalable method for simulating logical magic state preparation protocols under the standard circuit-level noise model. When applied to protocols based on code switching, magic state cultivation, and magic state distillation, our method yields a complexity polynomial in (i) the number of qubits and (ii) the non-stabilizerness, e.g., stabilizer rank or Pauli rank, of the target encoded magic state. The efficiency of our simulation method is rooted in a curious fact: every circuit-level Pauli error in these protocols propagates to a Clifford error at the end. This property is satisfied by a large family of protocols, including those that repeatedly measure a transversal Clifford that squares to a Pauli. We provide a proof-of-principle numerical simulation that prepares a magic state using such logical Clifford measurements. Our work enables practical simulation of logical magic state preparation protocols without resorting to approximations or resource-intensive state-vector simulations.
Fault-tolerant preparation of non-Clifford resource states is a major contributor to the overhead of quantum computation, motivating protocols that achieve high output fidelity with minimal qubit and circuit costs. We introduce a low-cost magic-state preparation protocol in which the choice of stabilizer generators is co-designed with the flag gadgets, allowing the syndrome-extraction circuit itself to filter correlated faults across a non-Clifford layer. The protocol prepares a logical plus state in the 15-qubit quantum Reed-Muller code, applies a transversal T gate, and gauge-fixes the same register into the seven-qubit Steane code. By reorganizing equivalent Z-type stabilizer generators into jointly flagged measurement groups, the protocol eliminates all accepted logical-error contributions arising from one or two circuit faults under destructive error detection. Under a uniform circuit-level depolarizing noise model, the postselected infidelity is 210.2p3+O(p4)210.2p^3+O(p^4)210.2p3+O(p4). At p=10−3p=10^{-3}p=10−3, exact low-order enumeration combined with stratified sampling bounds the infidelity by 2.2×10−72.2\times10^{-7}2.2×10−7 at 99.9% joint confidence, while retaining an acceptance probability of 86.9%. The complete circuit requires only 19 qubits and 82 CNOT gates. These results demonstrate that stabilizer-generator design can substantially reduce the cost of postselected magic-state preparation, although corrected operation and the fidelity of an unmeasured output block require separate analysis.
Benchmarking physical devices and verifying logical algorithms are important tasks for scalable fault-tolerant quantum computing. Numerous protocols exist for benchmarking devices before running actual algorithms. In this work, we show that both physical and logical errors of fault-tolerant circuits can even be characterized in-situ using syndrome data. To achieve this, we map general fault-tolerant Clifford circuits to subsystem codes using the spacetime code formalism and develop a scheme for estimating Pauli noise in Clifford circuits using syndrome data. We give necessary and sufficient conditions for the learnability of physical and logical noise from given syndrome data, and show that we can accurately predict logical fidelities from the same data. Importantly, our approach requires only a polynomial sample size, even when the logical error rate is exponentially suppressed by the code distance, and thus gives an exponential advantage against methods that use only logical data such as direct fidelity estimation. We demonstrate the practical applicability of our methods in various scenarios using synthetic data as well as the experimental data from a recent demonstration of fault-tolerant circuits by Bluvstein et al. [Nature 626, 7997 (2024)]. Our methods provide an efficient, in-situ way of characterizing a fault-tolerant quantum computer to help gate calibration, improve decoding accuracy, and verify logical circuits.
Fault-tolerant ∣T⟩|\sqrt{ \mathrm{T} }\rangle∣T​⟩ state preparation and injection for more efficient fine-grained quantum circuit synthesis
Magic-state injection is a standard route to realize universal fault-tolerant quantum computation. Whereas the set of Clifford gates in combination with the non-Clifford T gate is a widely used universal gate set, extending the available set of non-Clifford primitives can reduce compilation overhead, provided that the additional primitives can be prepared fault-tolerantly with competitive resource costs and at sufficiently low logical noise rates. In this work, we introduce flag fault-tolerant protocols for preparing logical $|\sqrt{\mathrm{T}} \rangle $ magic states on the 3D tetrahedral color code and its smaller morphed variant. Our simulations under circuit-level noise verify fault tolerance, quantify acceptance and logical error rates, and we reconstruct the effective logical channels of the corresponding circuits for gate injection via logical process tomography. We find that access to T\sqrt{\mathrm{T}}T​ reduces the average space-time cost of synthesizing Haar-random single-qubit unitaries by approximately 202020-303030% relative to the Clifford+T gate set across practically relevant approximation regimes. These results demonstrate how expanding the set of fault-tolerant non-Clifford primitives can improve computational efficiency and broaden the design space for universal quantum computation in the early fault-tolerant era.