Logical entanglement distribution between distant 2D array qubits

1. Problem Statement

The realization of fault-tolerant distributed quantum computing requires the efficient sharing of high-fidelity logical entangled pairs between distant quantum nodes. While physical entanglement generation between qubits is possible, current experimental limitations (probabilistic generation, noise, and decoherence) create a gap between physical capabilities and the theoretical requirements for logical states.

Existing protocols face specific trade-offs:

• One-to-one encoding: Simple but fails to leverage fast parallel generation rates; logical fidelity often remains close to physical fidelity.
• Remote Lattice Surgery: Can improve fidelity but requires $O(d)$ rounds of stabilizer measurements and is limited to 1D channel arrays, making it slow and inefficient for 2D architectures.
• The Gap: There is a lack of protocols that can efficiently utilize 2D qubit arrays with 2D channel connectivity to maximize the generation rate of logical entanglement while maintaining high fidelity, specifically addressing the probabilistic nature of physical entanglement generation.

2. Methodology

The authors propose a three-step protocol tailored for two distant nodes (Alice and Bob), each possessing a 2D square lattice of qubits ($L \times L$) connected by a 2D array of quantum channels.

Step 1: Probabilistic Physical Entanglement Generation

• Alice and Bob attempt to generate Bell pairs between qubits at identical coordinates in parallel.
• Success is probabilistic ($p_{gen}$), and generated pairs have an initial error rate ($e_{init}$).
• Due to decoherence, there is a trade-off between the success probability and the error rate based on the duration of the attempt.

Step 2: Qubit Rearrangement and Encoding (The Core Innovation)

• Rearrangement: Since successful entangled pairs are randomly distributed across the lattice, they must be moved to specific data qubit positions to form a valid surface code block.
  • The protocol uses SWAP gates (or atom shuttling) to move qubits.
  • A heuristic algorithm (minimum-weight maximum matching on a bipartite graph) minimizes the number of SWAP gates required, reducing the accumulation of local errors ($e_{swap}$).
• Syndrome Measurement & Post-Selection:
  • Alice and Bob perform stabilizer measurements on the rearranged lattice to map physical pairs into the logical code space.
  • Adaptive Post-Selection: This is the key feature. Bob estimates the number of Pauli errors based on the difference in syndrome values between Alice and Bob.
  • If the estimated error count exceeds a tunable threshold ($w_{thr}$), the protocol is aborted (post-selected out).
  • This creates a two-way communication loop where success probability ($p_{log}$) and logical error rate ($e_{log}$) can be tuned against each other.

Step 3: Post-Distillation

• The resulting logical pairs (which may still have errors higher than the target for fault tolerance) are fed into a standard entanglement distillation protocol (Step 3 in the general framework) to reach the final target fidelity (e.g., $10^{-13}$).

3. Key Contributions

1. Tunable Protocol: The authors introduce a protocol that allows operators to trade off success probability against logical fidelity via the acceptance threshold ($w_{thr}$). This enables optimization based on specific application needs (e.g., prioritizing speed vs. quality).
2. 2D Architecture Optimization: Unlike previous methods limited to 1D channels or requiring $d$ rounds of measurement, this protocol consumes $O(d^2)$ physical pairs in a single round of measurement, fully leveraging 2D parallelism.
3. Cross-Step Optimization: The paper demonstrates that optimizing Step 2 (encoding) is critical for the overall bandwidth of the system, not just Step 3 (distillation).
4. Feasibility Analysis: A comprehensive numerical evaluation using neutral atom arrays as a benchmark platform, showing that the protocol is feasible with near-future experimental parameters.

4. Results and Performance Evaluation

The authors numerically simulated the protocol under realistic neutral atom parameters (entanglement generation rate $p_{gen}$, lattice size $L$, initial error $e_{init}$, and SWAP gate error $e_{swap}$).

• Trade-off Curves: The simulations confirmed that increasing the acceptance threshold $w_{thr}$ increases the success rate ($p_{log}$) but degrades the logical error rate ($e_{log}$). Conversely, strict post-selection yields high fidelity at the cost of lower success rates.
• Fidelity Improvement: Even with noisy physical Bell pairs (e.g., $e_{init} = 0.05$) and imperfect SWAP gates ($e_{swap} \approx 0.03$), the protocol can generate logical entangled states with significantly lower error rates than the physical inputs.
  • Example: With $e_{swap} = 0.01$, logical error rates can be reduced to $\sim 1.5 \times 10^{-2}$ with a success probability of $\sim 0.11$.
• Code Distance Analysis: The study found that simply increasing the code distance ($d$) does not always improve performance if the physical error rates are high, as the increased number of SWAP gates required for rearrangement introduces more errors. An optimal $d$ must be chosen based on hardware noise levels.
• Bandwidth Estimation:
  • When combined with post-distillation to achieve a target logical error rate of $10^{-13}$, the protocol achieves a logical entanglement bandwidth of approximately 44 Hz (assuming cavity-assisted photon collection and optimized local operations).
  • Without cavity assistance, the rate is estimated at ~17 Hz.

5. Significance

• Bridging the Gap: This work provides a concrete, implementable roadmap for connecting fault-tolerant quantum computers using 2D devices (like neutral atoms or superconducting circuits), addressing the specific challenge of probabilistic entanglement generation.
• Scalability: By utilizing 2D channel arrays and parallel operations, the protocol offers a scalable path forward that avoids the latency bottlenecks of 1D lattice surgery.
• Design Baseline: The calculated bandwidth (44 Hz) and the trade-off curves provide essential design parameters for engineers building distributed quantum networks, helping them balance hardware requirements (SWAP gate fidelity, photon collection efficiency) with communication goals.
• Future Compatibility: While focused on surface codes, the framework is adaptable to other stabilizer codes (including qLDPC), making it a foundational contribution for the next generation of quantum error correction architectures.

In summary, Maeda et al. present a robust, tunable protocol that transforms noisy, probabilistic physical entanglement in 2D arrays into high-fidelity logical entanglement, effectively bridging the gap between current experimental capabilities and the requirements for large-scale distributed quantum computing.