Suppressing the Erasure Error of Fusion Operation in Photonic Quantum Computing

This paper introduces a new measurement-based quantum computing compilation scheme utilizing spin qubit quantum memory and a tree-encoded fusion strategy to effectively suppress photon-loss-induced erasure errors, demonstrating exponential performance improvements over existing methods like OneAdapt through both simulation and hardware validation.

The Gist

The Big Picture: Building a Quantum City with Light

Imagine you want to build a massive, intricate city (a Quantum Program) using only blocks of light (Photons). In this world, the blocks don't sit still; they fly around. To build your city, you have to catch two flying blocks and snap them together. This snapping process is called Fusion.

If you snap them together perfectly, you get a solid wall. If you miss, the blocks just bounce off. But here's the tricky part: sometimes, a block flies away and disappears into the void before anyone can see it. In the world of quantum computing, this is called an Erasure Error.

For a long time, scientists building these light-cities only worried about "missing the snap" (Fusion Failure). They built safety nets for that. But they ignored the "disappearing block" (Erasure). If a block vanishes, the whole blueprint of your city becomes a mystery. You don't know if the wall is there or not, so you have to tear down the whole neighborhood and start over. This makes building the city incredibly slow and expensive.

The Problem: The "Ghost" Blocks

The authors of this paper realized that previous methods (like the famous "OneAdapt" compiler) were like construction crews that had a plan for dropped bricks but no plan for bricks that turned into ghosts.

• Fusion Failure: You try to snap two blocks, miss, and you know, "Oh, I missed. Let's try again." The rest of the city is safe.
• Fusion Erasure: You try to snap two blocks, but one vanishes. You look at the spot and say, "Is the wall there? Is it gone? Did it snap but the block disappeared?" You have no idea. This uncertainty is catastrophic. It forces the computer to restart the whole program, wasting huge amounts of time and energy (photons).

The Solution: The "Tree-Encoded" Safety Net

The team, working with a specific type of hardware called Spin Memory (think of it as a factory that can spin out long chains of light-blocks), came up with a brilliant new strategy called Tree-Encoded Fusion.

The Analogy: The Treehouse vs. The Single Ladder

Old Way (Redundant Encoding):
Imagine you need to cross a river to deliver a message. The old method says, "Let's build 5 identical ladders. If one breaks, we use another."

• The Flaw: If a ladder breaks, you know. But if a ladder vanishes (erasure), you still don't know if the message got across. Plus, building 5 ladders uses a lot of wood (photons).

The New Way (Tree-Encoded Fusion):
Imagine you build a Treehouse with a main trunk and several branches.

1. The Trunk: This is your main message.
2. The Branches: These are extra safety lines.
3. The Magic Trick: If one branch disappears (erasure), the treehouse has a special rule: "If a branch is missing, look at the leaves on the other branches to figure out what the missing branch was supposed to say."

It's like having a backup plan that doesn't just "try again," but actually deduces what happened even when a piece is missing. By using this "Tree" structure, they can catch the "ghost" blocks and fix the blueprint without tearing down the whole city.

The "MemTree" Compiler: The Smart Architect

The paper introduces a new software tool called MemTree. Think of this as a super-smart architect who designs the construction schedule.

1. Divide and Conquer: Instead of trying to build the whole city at once, MemTree breaks the city into small, manageable neighborhoods (called Caterpillar States).
2. The Assembly Line: It organizes the construction so that if one neighborhood fails to connect, it doesn't stop the whole factory. It just pauses that specific line and tries again, while the rest of the factory keeps working.
3. Efficiency: Because the "Tree" method is so good at handling disappearing blocks, the architects don't need to build as many backup ladders. They use fewer resources (photons) and finish the job much faster.

The Results: Speed and Reliability

The team tested their new method against the old best methods:

• Speed: They found that their method is exponentially faster. If the old method took 100 hours to build a complex quantum program, the new method might take only a few minutes.
• Reliability: The "Tree" method is much better at ignoring the "ghost" blocks. The final city (the quantum result) is much more accurate.
• Real-World Test: They didn't just run this on a computer simulation; they actually built a small version on real hardware (a Quandela quantum computer) and proved it works in the real world.

Summary: Why This Matters

Think of Photonic Quantum Computing as a race to build a skyscraper using flying bricks.

• Before: The builders were terrified of bricks disappearing. If one vanished, they had to stop and start over, making the race incredibly slow.
• Now (MemTree): The builders learned how to build a "Tree" structure. If a brick vanishes, the tree automatically adjusts and keeps the building standing.

This breakthrough means we can finally build complex quantum programs efficiently, bringing us one step closer to computers that can solve problems no supercomputer today can touch. It turns a fragile, error-prone process into a robust, reliable one.

Technical Summary

1. Problem Statement

Photonic Quantum Computing (PQC) relies on the Measurement-Based Quantum Computation (MBQC) model, where computation is executed via measurements on a pre-generated entangled graph state. The construction of these graph states depends on fusion operations, which are inherently probabilistic and prone to two distinct error types:

• Fusion Failure: The entanglement attempt fails, but the outcome is known (heralded). The qubits are measured out, and the graph structure remains known.
• Fusion Erasure: Caused by photon loss, where a qubit is not detected. The outcome is unknown, making the resulting graph state uncertain. This is significantly more damaging than failure because it corrupts the graph structure required for subsequent measurements.

Limitations of Prior Work:

• OneAdapt (SOTA for All-Photonic): Focuses on handling fusion failures using normalization methods but ignores fusion erasure. It suffers from low photon resource utilization and exponential overhead when erasure rates are non-zero.
• RLGS (SOTA for Emitter-based): Relies on deterministic emitter interactions but is currently limited by the lack of experimental demonstration for high-fidelity emitter-to-emitter CZ gates.
• Existing Boosted Schemes: Redundant encoding and Repeat-Until-Success (RUS) schemes improve failure tolerance but exacerbate erasure errors by exposing more qubits to photon loss.

2. Methodology

The authors propose MemTree, a compilation framework built upon the Quantum Spin Memory architecture (using semiconductor quantum dots to generate "caterpillar" graph states). The solution consists of three core components:

A. Tree-Encoded Fusion Scheme

Inspired by Quantum Error Correction (QEC) tree codes, the authors introduce a new encoding strategy to suppress both fusion failure and erasure.

• Structure: A logical qubit is encoded as a tree structure with a root qubit ($q_{root}$) connected to $b$ branches. Each branch consists of a linear chain of 3 qubits: two ancillary qubits ($q_a, q_b$) and one leaf qubit ($q_c$) used for the fusion attempt.
• Error Handling Mechanisms:
  • Fusion Success: Standard X-measurements on ancillas connect the successful entanglement to the root.
  • Fusion Failure: The failed leaf is measured out; the remaining ancillas are preserved for backup attempts.
  • Fusion Erasure (Key Innovation): If a leaf qubit is lost (erased), the system performs an indirect Z-measurement. By measuring the ancillary qubits ($q_a, q_b$) in specific bases (X and Z), the system deterministically infers the outcome of the lost qubit without needing to detect it physically. This effectively removes the erasure error without collapsing the entire graph state.
• Parameters: The scheme uses an encoding parameter $b$ (number of branches) and a preparation parameter $b_{prep}$ (attempts to prepare branches). The authors optimize these to $b=4$ and $b_{prep}=6$ for near-term hardware constraints.

B. MemTree Compilation Framework

The compiler generates the target graph state from primitive caterpillar states using a Hierarchical Generation approach.

• Divide-and-Conquer: The target graph is divided into linear subgraphs using a Mixed-Integer Programming (MIP) solver. Constraints ensure subgraphs fit the caterpillar structure (max degree 2).
• Balanced Binary Tree (BBT): The generation process is modeled as a BBT. Subgraphs are fused layer-by-layer.
• Critical Path Optimization: The algorithm minimizes the "critical path" (the longest chain of sequential fusions) to reduce execution time. If a fusion fails at a node, only that specific subtree needs regeneration, rather than the entire graph.
• Pipeline: The system operates as a pipeline where photon sources emit caterpillar states, which are processed through fusion layers. Failed branches trigger feed-forward controls to delay sibling branches until recovery is successful.

C. Realistic Simulation and Hardware Validation

• Simulator: A noise-aware simulator incorporating fusion failure ($p_{fail}$), erasure ($p_{eras}$), decoherence, and coherent errors, calibrated against experimental data from PsiQuantum and Quandela.
• Hardware Demo: A proof-of-concept experiment was conducted on the Quandela Benlenos photonic QPU.

3. Key Contributions

1. Novel Error Model: First to explicitly model and mitigate fusion erasure (photon loss) in MBQC compilation, addressing a critical gap left by OneAdapt and other SOTA compilers.
2. Tree-Encoded Fusion: A new encoding scheme that leverages indirect measurements to tolerate erasure, achieving significantly higher robustness than redundant encoding or RUS schemes, especially at high erasure rates.
3. MemTree Compiler: A scalable compilation framework tailored for spin-memory architecture that minimizes execution time and photon resource overhead via hierarchical generation and MIP-based optimization.
4. Real-Hardware Validation: The first photonic MBQC compiler evaluation that includes a demonstration on real hardware (Quandela), validating the theoretical gains in a physical system.

4. Results

The framework was evaluated against OneAdapt, RLGS, and standard boosted fusion schemes (Redundant, RUS) across six benchmarks (VQE, QAOA, Grover, etc.) ranging from 36 to 100 qubits.

• Execution Time: MemTree achieved an exponential improvement over OneAdapt.
  • Reduction factors ranged from $1.5 \times 10^{-2}$ to $5.6 \times 10^{-3}$ (i.e., 18x to 180x faster) depending on the algorithm and erasure rate.
  • Compared to RUS and Redundant schemes, execution time was reduced by factors of $1.7 \times 10^{-2}$ and $1.9 \times 10^{-3}$, respectively.
• Resource Efficiency:
  • Photon Sources: MemTree required 0.18× the number of photon sources compared to OneAdapt.
  • Compilation Runtime: Reduced by 0.14× compared to OneAdapt.
• Fidelity:
  • MemTree showed a 3.64× improvement in fidelity over OneAdapt.
  • It outperformed RLGS by 1.42× in fidelity.
  • The scheme effectively suppressed errors that would otherwise accumulate due to long execution times (decoherence).
• Hardware Experiment: On the Quandela QPU, MemTree (using SU2 ansatz) achieved:
  • 2.68× higher Probability of Successful Trial (PST) compared to RUS on photonic hardware.
  • 2.20× higher PST compared to Qiskit transpilation on IBM superconducting hardware.
  • 3.23× higher Inference Strength (IST) compared to RUS on photonic hardware.

5. Significance

This work represents a major step forward in making Photonic Quantum Computing viable for near-term applications.

• Bridging Theory and Practice: By addressing the often-overlooked "erasure" error, the paper moves PQC compilation from idealized failure models to realistic hardware constraints.
• Scalability: The hierarchical generation and tree-encoding allow for the construction of large-scale graph states without the exponential resource explosion seen in previous methods.
• Architecture Agnostic Potential: While tailored for spin-memory, the loss-tolerant logical fusion concept can be adapted to all-photonic architectures, potentially revolutionizing how graph states are generated across the PQC field.
• Validation: The successful demonstration on real hardware proves that the theoretical benefits of error-tolerant compilation translate to tangible performance gains in physical quantum systems.