INJEQT: Improved Magic-State Injection Protocol for Fault-Tolerant Quantum Extractor Architectures

This paper introduces INJEQT, an improved magic-state injection protocol for fault-tolerant quantum extractor architectures that utilizes a 2-factory design and pre-fetching strategy to significantly reduce error rates, wall-clock time, and space-time costs by minimizing expensive inter-module measurements during non-Clifford gate execution.

The Gist

Imagine you are trying to build a massive, incredibly delicate castle out of glass. This castle represents a Fault-Tolerant Quantum Computer. To keep it standing, you need a special "magic glue" (called Magic States) to hold the most important, non-standard pieces together. Without this glue, the castle collapses.

However, making this magic glue is dangerous. The process is so prone to mistakes that it causes 90% of all the errors in your entire construction project.

This is the problem the paper INJEQT tries to solve. Here is how they fixed it, explained simply:

The Problem: The "Expensive Messenger"

In current quantum computer designs (called Extractor Architectures), the process works like this:

1. You have a main construction site (the Extractor Module).
2. You have a separate factory that makes the magic glue (the Factory).
3. To get the glue to the construction site, you have to send a messenger across a dangerous bridge (Inter-module Measurement).

The paper found that this bridge is the most dangerous part of the whole trip. Every time you send a messenger, there's a high chance they drop the glue or get lost. Since you need to send many messengers to build complex structures, the bridge becomes the weak link that ruins your whole project.

The Solution: INJEQT (The "Two-Factory Relay")

The authors, Sayam Sethi and his team, proposed a new system called INJEQT. Instead of sending the raw, dangerous glue directly across the bridge, they changed the strategy:

1. The Intermediate Stop: They built a second, safer "preparation kitchen" (an Auxiliary Code, like a Surface Code) right next to the main site.
2. The Relay Race:
   • The original factory makes a basic ingredient.
   • This ingredient is sent to the safe kitchen.
   • In the safe kitchen, they mix it into the final, perfect "Magic Glue" (an Rz state).
   • Because this kitchen is safer, the mixing process makes fewer mistakes.
   • Finally, they send this already-mixed glue across the dangerous bridge just once.

The Analogy: Imagine you are baking a cake.

• Old Way: You buy raw, unstable eggs from a risky farm, drive them across a bumpy, dangerous road to your kitchen, and then try to crack them. If the road shakes them too much, the eggs break, and you have to start over.
• INJEQT Way: You buy the eggs, drive them to a safe, smooth "pre-kitchen" nearby. You crack and mix them there safely. Then, you drive the already-mixed batter across the bumpy road. Even if the road shakes, the batter is much harder to ruin than raw eggs.

The Catch: It Takes Longer (The "Traffic Jam")

There was a downside. By adding this extra "pre-kitchen" step, the process became slower. It was like adding a stop at a rest area; you arrive safer, but you get there later.

The Fix: "Pre-Fetching" (The "Assembly Line")

To fix the speed issue, the authors introduced a Pre-fetching strategy.

Imagine a conveyor belt. Instead of waiting for the first batch of batter to be mixed before starting the next, they set up multiple kitchens working at the same time.

• While Kitchen A is delivering the current batch, Kitchen B is already mixing the next batch.
• Kitchen C is mixing the batch after that.
• If the first batch needs a correction (a "fix"), the next one is already ready to go instantly.

This turns a slow, single-lane road into a busy, multi-lane highway.

The Results: What Did They Achieve?

The paper tested this system against standard methods using different types of "factories" (Distillation, Cultivation, and STAR). Here is what they found:

• Fewer Mistakes: The new system reduced the total error rate by up to 22 times (for some factory types). It made the "bridge" much less critical because the glue was already perfect before it crossed.
• Faster Execution: Thanks to the "Pre-fetching" assembly line, the total time to run a program improved by up to 13 times.
• Space Efficiency: They managed to do all this without needing a massive amount of extra space. In the worst case, they only needed about 25% more space, but on average, it was a very small increase (3–10%).

Summary

INJEQT is a new blueprint for quantum computers that says: "Don't send the fragile, raw materials across the dangerous bridge. Mix them in a safe zone first, and have multiple teams ready to go so you never have to wait."

This allows quantum computers to run complex programs with far fewer crashes and much faster speeds, making the dream of a reliable quantum computer a little more realistic.

Technical Summary

1. Problem Statement

Fault-Tolerant Quantum Computing (FTQC) architectures based on spatially efficient quantum error correcting codes (QECC), such as the bivariate-bicycle (Gross) code family, rely on an extractor-based architecture. A critical bottleneck in these systems is the execution of non-Clifford operations, which require magic-state injection.

• The Bottleneck: In current designs (e.g., Tour de Gross), non-Clifford gates are implemented by synthesizing $R_z(\theta)$ rotations using a sequence of $|T\rangle$ states. This process, known as synthillation, involves multiple sequential injections.
• The Error Source: Each injection requires an inter-module measurement (connecting the magic-state factory to the logical processing unit). This is the most expensive instruction in the architecture in terms of error rates.
• Impact: The authors observe that over 90% of the total program infidelity (error) in these architectures stems from the synthillation process, specifically the inter-module measurements required for sequential $|T\rangle$ injections.
• Trade-off Challenge: While reducing errors is critical, simply adding more error-correction layers often increases execution time (latency) and space overhead (qubit count), creating a difficult space-time trade-off.

2. Methodology: The INJEQT Protocol

The authors propose INJEQT, a novel 2-factory design that optimizes the trade-off between error rates and execution time.

A. Core Concept: 2-Level Factory Architecture

Instead of injecting $|T\rangle$ states directly into the extractor module (which requires many sequential inter-module measurements), INJEQT introduces an auxiliary code (specifically the Surface Code in this study) as an intermediate layer.

1. Level 1 (Auxiliary Synthesis): $|T\rangle$ states are injected into the auxiliary Surface Code to synthesize a high-fidelity $R_z(\theta)$ state. This synthesis happens within the auxiliary code using lattice surgery or transversal CNOTs, which have lower error rates than inter-module measurements.
2. Level 2 (Extraction): The synthesized $R_z(\theta)$ state is then injected once into the main extractor module via a single inter-module measurement.
3. Correction Handling: Since $R_z$ injection is probabilistic (failing 50% of the time and requiring a correction of $R_z(2\theta)$), the protocol accounts for potential recursive corrections.

B. Optimization: Pre-fetching Strategy

A naive implementation of the 2-level factory would increase execution time because the auxiliary synthesis takes time. To mitigate this, INJEQT employs a pre-fetching strategy:

• Parallel Preparation: Multiple 2-level factories ($R$ factories) operate in parallel. They prepare not just the current required $R_z(\theta)$ state, but also potential correction states ($R_z(2\theta), R_z(4\theta), \dots$) in advance.
• Pipeline Overlap: The preparation of these states occurs simultaneously with the setup phase of the extractor modules (in-module and inter-module measurements), effectively hiding the latency of the synthesis.
• Dynamic Selection: If a correction is needed, the pre-prepared state is immediately available; if not, the factory immediately begins preparing the next unneeded state.

3. Key Contributions

1. Error Reduction via Architecture Change: The paper identifies that inter-module measurements are the dominant error source. By shifting the bulk of the synthesis work to an auxiliary code (Surface Code) and reducing the number of inter-module injections from $O(c)$ (where $c \approx 80-100$ for GridSynth) to a constant (typically 1 or 2), the overall error budget is drastically reduced.
2. Time-Optimized Pre-fetching: The authors introduce a pipelined factory approach that resolves the latency penalty of the 2-level design, achieving significant improvements in wall-clock time.
3. Comprehensive Evaluation: The study rigorously evaluates INJEQT across:
   • Three factory paradigms: Distillation, Cultivation, and STAR.
   • Two injection models: Lattice Surgery and Transversal CNOT.
   • A wide benchmark suite (QASMBench) including arithmetic, optimization, and simulation circuits.

4. Key Results

The evaluation demonstrates that INJEQT significantly outperforms the baseline Tour de Gross (TDG) architecture across multiple metrics:

Metric	Distillation Factory	Cultivation Factory	STAR Factory
Program Error Reduction	~11% average (up to 12.5%)	~12.5× average (up to 20×)	~10× average (up to 18×)
Wall-Clock Time Improvement	~7× average (up to 13×)	~6.5–7× average (up to 8.8×)	~9× average (up to 12×)
Space-Time Cost Reduction	~2× average (up to 7.2×)	~1.5–2.5× average (up to 4.5×)	~12× average (up to 16×)
Space Overhead	+2.5% to 5% (avg)	+7% to 13% (avg)	~4% reduction (due to smaller footprint)

• Robustness: INJEQT is robust across different device technologies (superconducting vs. neutral atom) and factory choices.
• Factory Count Sensitivity: The optimal number of pre-fetching factories ($R$) varies by benchmark, but improvements in wall-clock time saturate quickly (often with $R < 20$), meaning a modest increase in hardware resources yields near-maximal performance gains.
• STAR Factory: Since STAR directly synthesizes $R_z$ states, it does not require the second-level factory for synthesis, yet INJEQT's pre-fetching logic still provides massive gains in execution time and space-time cost.

5. Significance

• Enabling FTQC Scalability: By reducing the error contribution of non-Clifford operations from >90% to a manageable fraction, INJEQT makes the execution of large-scale quantum algorithms on spatially efficient qLDPC codes (like the Gross code) feasible.
• Redefining Space-Time Trade-offs: The work challenges the assumption that lower error rates must come at the cost of prohibitive time or space overhead. INJEQT demonstrates that intelligent architectural pipelining can simultaneously lower error rates and reduce execution time.
• Hardware Agnosticism: The protocol is compatible with various underlying physical qubit technologies and injection methods, making it a versatile design pattern for future FTQC system architects.

In conclusion, INJEQT represents a critical advancement in quantum compiler and architecture design, offering a practical pathway to mitigate the dominant error sources in next-generation fault-tolerant quantum computers.