Magic state distillation with permutation-invariant codes and a two-qubit example

Abstract: Magic states, by allowing non-Clifford gates through gate teleportation, are important building blocks of fault-tolerant quantum computation. Magic state distillation protocols aim to create clean copies of magic states from many noisier copies. However, the prevailing protocols require substantial qubit overhead. We present a distillation protocol based on permutation-invariant gnu codes, as small as two qubits. The two-qubit protocol achieves a 0.5 error threshold and 1/2 distillation rate, surpassing prior schemes for comparable codes. Our protocol furthermore distils magic states with arbitrary magic by varying the position of the ideal input states on the Bloch sphere. We achieve this by departing from the usual magic state distillation formalism, allowing the use of non-Clifford gates in the distillation protocol, and allowing the form of the output state to differ from the input state. Our protocol is compatible for use in tandem with existing magic state distillation protocols to enhance their performance.

• The paper presents a novel magic state distillation protocol using permutation-invariant gnu codes to outperform traditional stabilizer methods.
• It achieves a two-qubit implementation with an error threshold of 0.5, exceeding previous thresholds of 0.173 and 0.141 for |T⟩ and |H⟩ states.
• The protocol flexibly distills a continuum of magic states by tuning input Bloch parameters, enabling integration into hybrid distillation pipelines.

Magic State Distillation with Permutation-Invariant Codes and a Two-Qubit Example

Introduction

Magic state distillation (MSD) is a cornerstone of fault-tolerant quantum computation, enabling the practical implementation of non-Clifford gates required for quantum universality. Though MSD greatly improves resilience to noise, traditional distillation protocols incur substantial resource overhead, motivating efforts toward compact and efficient schemes. This work introduces a magic state distillation protocol leveraging permutation-invariant gnu codes, providing, notably, a viable two-qubit implementation with superior error thresholds and distillation rates compared to prior small-code protocols.

Background and Motivation

MSD protocols conventionally exploit stabilizer codes, such as those of Bravyi-Kitaev and Reichardt, for the distillation of canonical magic states like $|T\rangle$ and $|H\rangle$. These methods require substantial qubit resources—even the most compact among prior works employ at least three to five physical qubits for each distillation round, with the threshold for error suppression limited accordingly. Furthermore, most established protocols restrict the range of accessible magic states, typically focusing solely on $|T\rangle$ and $|H\rangle$.

Permutation-invariant codes, specifically the gnu family, offer a highly symmetric, non-stabilizer structure, naturally suiting experimental platforms and enabling simplified control. Their use in quantum error correction and metrology is established, but their suitability for MSD remains underexplored. This work systematically investigates such codes for concise and tunable magic state distillation.

Protocol Construction

The protocol begins from $N$ noisy copies of a configurable single-qubit input state, parameterized on the Bloch sphere. These are projected into the logical subspace of a gnu code, followed by a decoding operation. Significantly, the non-Clifford gates inherent to the protocol's realization enable a departure from traditional MSD formalisms, relaxing the restriction that the output state must identically match the input and permitting a broader class of distilled magic states.

For the minimal two-qubit case, logical states are defined as $|0_{1,1,2}\rangle = |00\rangle$ and $$|1_{1,1,2}\rangle = (|10\rangle + |01\rangle)/\sqrt{2}$$. The efficient circuit (Figure 1(b)) comprises seven CNOTs—including a controlled-Hadamard decomposition—and single-qubit rotations, greatly simplifying implementation for near-term devices.

Figure 1: (a) Comparison of error thresholds and rates: the proposed protocol outperforms prior small-code schemes. (b) Circuit for the two-qubit protocol using the gnu code. (c) Achievable magic via parameter tuning on input states.

Achievable Magic and Versatility

A central feature of this protocol is its flexibility: the distilled state's magic is entirely determined by the input state's position on the Bloch sphere—captured by parameters $v$ and $\theta$. Thus, the same circuit can distil a continuous spectrum of magic values, interpolating between the $|T\rangle$, $|H\rangle$, and more exotic non-stabilizer states. The 2-Rényi entropy of output states, serving as a robust magic monotone, confirms the ability to distil arbitrary target magic levels (Figure 1(c)).

Error Suppression and Thresholds

Numerical evaluation of trace distance between the output and target magic states reveals the strong noise resilience of the permutation-invariant codes (Figure 2). For the two-qubit protocol, an error threshold of $0.5$ is observed—a substantial improvement over prior stabilizer-based counterparts, which achieve $0.173$ ($|T\rangle$) and $0.141$ ($|H\rangle$), as summarized by Bravyi-Kitaev and Reichardt, respectively. Notably, the proposed protocol maintains effective error suppression while using fewer qubits and remains competitive for moderate fidelity ranges.

Figure 2: (a) Input state parametrization for targeted distillation. (b,c) Maximum output error as a function of input error, contrasting the protocol's performance for $|T\rangle$ and $|H\rangle$ against prior works.

Synergy with Existing Protocols

While the proposed gnu code-based approach is not inherently fault-tolerant (owing to the non-Clifford operations utilized), it serves as a powerful pre-distillation layer in composite MSD pipelines. When used to precondition inputs for higher-order stabilizer-based distillation, the combined scheme achieves notably increased error thresholds with only linear qubit overhead—e.g., boosting the $|T\rangle$ threshold from $0.173$ to $0.279$ (Figure 3). This hybrid approach efficiently delivers higher fidelity magic states while maintaining resource economy.

Figure 3: (a) Schematic for combining the protocol with standard MSD. (b) Output error suppression and threshold enhancements for $|T\rangle$ and $|H\rangle$ in hybrid schemes.

Comparison with Repetition Codes

An explicit performance comparison with the two-qubit repetition code—effectively a gnu code with $g=2, n=u=1$—demonstrates a lack of nontrivial error suppression, establishing the specificity of the advantages conferred by true permutation-invariance beyond the simple repetition code structure (Figure 4).

Figure 4: Maximum error for a two-qubit repetition code shows no error suppression versus input error, underscoring the uniqueness of the proposed approach.

Practical and Theoretical Implications

This protocol yields several impactful consequences for quantum architectures:

• Practicality: The minimal gate count and qubit footprint make the protocol well-suited for implementation on present-day quantum devices such as trapped ions or superconducting qubits, providing a route toward experimental demonstrations of MSD in regimes inaccessible to previous protocols.
• Versatility: By simply tuning input parameters, a wide continuum of magic states can be distilled, facilitating the synthesis of resource states for arbitrary-angle rotations and exotic non-Clifford gates.
• Scalability: The demonstrated benefits in composite schemes suggest that gnu-based MSD modules can serve as general-purpose error reduction primitives in layered quantum computation workflows, compatible with code switching and code concatenation.

From a theoretical perspective, these results underscore the untapped potential of non-stabilizer codes for resource state distillation and pave the way for generalizations to larger permutation-invariant code families and novel resource-theoretic quantifiers of code performance.

Conclusion

Permutation-invariant gnu code-based magic state distillation achieves error thresholds and rates previously unattainable with minimal hardware resources, enables distillation of arbitrary magic states via input tuning, and slots efficiently into multi-stage distillation pipelines for further noise suppression. This approach highlights new pathways in the design and implementation of compact, flexible resource state factories and motivates the systematic exploration of non-stabilizer code structures for quantum information processing (2603.04310).