⚛️ quantum physics

Constant sized support state distillation with qubit recycling

This paper introduces a recursive family of magic state distillation protocols that leverage code doubling and qubit recycling to achieve arbitrary error-correcting distances using a constant number of logical qubits, thereby recovering known efficient methods and discovering new, volume-compact protocols for producing high-fidelity diagonal states across the Clifford hierarchy.

Original authors: Victor Barizien

Published 2026-09-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Victor Barizien

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that are currently impossible for classical machines, from designing new medicines to cracking complex codes. However, these machines are incredibly fragile. The delicate quantum states they rely on are easily disrupted by the slightest bit of noise or interference from the environment. To build a useful machine, scientists must use a technique called quantum error correction, which acts like a shield, constantly checking for mistakes and fixing them before they ruin the calculation. Yet, there is a catch. While error correction can protect data, it cannot easily perform every type of calculation required for a universal computer. Specifically, it struggles with a certain class of operations that are essential for speed and versatility. To get around this, researchers use a workaround involving special helper states, often called "magic states," which are injected into the system to enable these difficult operations.

The problem is that these helper states are hard to make perfectly. They usually come out of the factory with a high rate of errors, far too noisy to be useful for a reliable calculation. To fix this, scientists use a process called distillation. This is akin to refining crude oil: you take many noisy, low-quality copies of the state and process them together to produce a smaller number of high-quality, clean copies. The challenge has always been that this refining process requires a massive amount of hardware. It needs a large number of physical components to hold the data while it is being processed, making the entire operation bulky and expensive in terms of the resources required.

In a new study, a researcher at the University of Geneva has found a way to shrink this massive hardware requirement dramatically. The work introduces a new family of methods for distilling these magic states that can achieve extremely high levels of purity while using a fixed, small number of qubits, regardless of how perfect the final result needs to be. Previously, if a scientist wanted to increase the reliability of the output, they had to build a larger machine with more qubits to handle the extra work. This new approach breaks that rule. By using a clever trick called qubit recycling, the protocol allows the same small group of qubits to be used over and over again in a sequence, rather than needing a fresh, larger group for every step.

The researcher developed a recursive method, essentially a set of instructions that can be applied again and again to build more powerful distillation protocols. This method starts with a simple, basic building block and uses a technique known as code doubling to construct more complex versions. The key innovation lies in how the qubits are managed. In traditional methods, many qubits sit idle or are used only once. In this new framework, the researcher showed that certain qubits can be measured, reset, and immediately reused for a different part of the calculation. This means that for a specific level of computational power, the number of qubits needed does not grow as the desired quality of the output increases. Instead, the protocol can reach arbitrarily high distances—a measure of how well it can detect and correct errors—using the same constant number of logical qubits.

The paper demonstrates that this approach recovers many known efficient protocols but also uncovers entirely new ones that are far more compact. For example, the study identifies a specific protocol for distilling a state used in the most common quantum computing architectures that uses only 111 input states to produce one high-quality output. While this might sound like a large number of inputs, the physical footprint of the machine required to run it is remarkably small. The researcher calculated that this specific protocol can be performed on just six qubits. This is a significant reduction compared to other known methods that might require over ten qubits to achieve the same level of error protection. The study provides a detailed table comparing these new protocols against existing ones, showing that the new methods consistently offer a much smaller "volume" of resources, which is the product of the number of qubits and the time steps required.

This reduction in size is not just a minor improvement; it changes the feasibility of building these machines. In many proposed quantum computer designs, the ability to connect qubits is limited. Having a protocol that works with a small, fixed number of qubits makes it much easier to fit the distillation factory into these constrained architectures. The researcher also explored how this method could be extended to produce more than one high-quality state at a time. While the efficiency gains for multiple outputs are not as dramatic as for single outputs, the framework still allows for significant resource savings. The work suggests that by carefully ordering the steps of the calculation and reusing components, the physical cost of making these essential magic states can be brought down to a manageable level.

The findings are presented as a mathematical construction that has been rigorously proven to work. The researcher did not just suggest that this might work; they provided a formal proof that these new protocols maintain the necessary properties to correct errors effectively. The study also acknowledges that while the number of qubits is constant, the time it takes to run the protocol does increase as the desired quality goes up. However, in the context of building a quantum computer, saving on the number of physical components is often the most critical bottleneck. By showing that high-fidelity distillation is possible with a constant, small number of qubits, this research offers a clear path toward more practical and compact quantum error correction systems. The work concludes by noting that while other techniques like running operations in parallel could further reduce costs, the ability to recycle qubits in this specific way provides a foundational improvement that makes the entire process of building a fault-tolerant quantum computer more attainable.

Technical Summary: Constant Sized Support State Distillation with Qubit Recycling

Problem Statement
Fault-tolerant quantum computation requires a universal set of logical gates. However, the Eastin–Knill theorem precludes a universal set of transversal gates for any quantum error-correcting code (QECC) that corrects local errors. Consequently, standard architectures (e.g., surface codes) rely on magic state injection to perform non-Clifford operations. This approach necessitates high-fidelity magic states, as current preparation methods yield error rates ( $\sim 10^{-3}$ ) far exceeding the thresholds required for reliable computation ( $\sim 10^{-10}$ ). Magic state distillation addresses this by consuming multiple noisy copies to produce fewer, higher-quality copies.

A critical bottleneck in distillation is the resource overhead, specifically the "qubit volume," defined as the product of the number of support qubits ( $s$ ) and the protocol depth ( $n$ ). While recent work has shown that qubit recycling (measuring and re-initializing idle check qubits) can reduce resource requirements, existing protocols often require a support size that scales with the code distance $d$ . This paper addresses the challenge of constructing distillation protocols that maintain a constant number of logical qubits regardless of the target distance $d$ .

Methodology
The paper introduces a recursive family of binary matrices that define magic state distillation protocols for states at arbitrary levels $r$ of the Clifford hierarchy. The core methodology relies on two main components:

Code Doubling (Level Lifting): The author utilizes a canonical procedure known as code doubling to construct higher-distance codes from existing ones. Starting with a weakly $r$ -orthogonal matrix $G$ (distance $d$ ) and a weakly $(r-1)$ -orthogonal matrix $H$ (distance $d+2$ ), a new matrix $G'$ is constructed. This construction preserves the orthogonality conditions required for distillation while increasing the distance by 2.
Recursive Construction: By initializing the recursion with specific elementary 1-orthogonal matrices (based on shortened Reed-Muller structures), the author generates a family of matrices $G(r, d)$ that produce a single output state at the $r$ -th level of the Clifford hierarchy with arbitrary distance $d$ .
Qubit Recycling Analysis: The paper analyzes the "recycled support" $s^\star(G)$ , which represents the minimum number of physical qubits required to execute the protocol by reusing check qubits mid-circuit. The recursive structure of the code doubling construction allows for an analytical upper bound on this recycled support.

Key Contributions

Constant Support Protocols: The primary contribution is the demonstration that for a fixed Clifford level $r$ , the derived distillation protocols can be executed on a constant number of logical qubits, independent of the distance $d$ . Specifically, the recycled support is bounded by $s^\star(G(r,d)) \le 2^r$ . For example, $|T\rangle$ state distillation ( $r=3$ ) can be performed on a fixed support of 6 qubits for any distance $d$ .
New Efficient Protocols: The construction recovers known efficient protocols (e.g., Steane code for $d=3$ , 2D self-dual color code for $d=5$ ) and uncovers new, more compact protocols. Notably, the paper identifies a $111 \to 1$ protocol for $|T\rangle$ distillation at distance 7, which is the most compact in terms of volume (support $\times$ depth) compared to previous constructions.
Extension to Multi-Output States: The framework is extended to protocols producing $k > 1$ $k > 1$ output states. The author presents two new code doubling constructions:
- One for producing $k$ outputs with distance $d=2$ .
- One for producing 2 outputs with arbitrary distance $d$ .
  While these multi-output protocols also benefit from qubit recycling, the author notes that for the 2-output case, the recycled support scales linearly with $d$ (bounded by $d^{r-1}$ ), rather than remaining constant.

Results
The paper provides explicit parameters for the generated families of codes.

Single Output ( $k=1$ ): For $r=3$ (distilling $|T\rangle$ states), the protocol parameters scale as $n(G) \sim d^3$ and $s(G) \sim d^3$ , but the recycled support remains constant at $s^\star \le 6$ . Table I compares these results with literature, showing that for $d=7$ , the new protocol has an effective overhead of $666 $($ 6 \times 111$), significantly lower than the $1045 $($ 11 \times 95$) overhead of a previously known distance-7 protocol constructed via Golay code doubling.
Multi-Output ( $k>1$ ): Table II lists parameters for 2-output protocols. For $r=3$ and $d=3$ , the protocol achieves optimal depth. The construction allows for the generation of codes with arbitrary distance $d$ for $k=2$ , though the support reduction is less dramatic than in the single-output case.

Significance and Claims
The paper claims that this work provides a family of distillation protocols that substantially reduce the effective qubit overhead for high-distance distillation. By decoupling the required support size from the target distance, these protocols are particularly relevant for architectures with limited logical qubit connectivity or strict qubit count constraints.

The author emphasizes that comparing distillation protocols is complex, as it involves balancing depth, support, and parallelization. While this work focuses on minimizing the support size via recycling, it acknowledges that other techniques (such as gate parallelization or catalytic protocols) could further optimize overhead. The work concludes by posing an open question: whether it is possible to construct families of codes for arbitrary $d$ and arbitrary $k$ that maintain a constant recycled qubit support.

More like this