⚛️ quantum physics

Heralded photonic graph states with inefficient quantum emitters

This paper proposes a heralded scheme for generating photonic graph states using inefficient quantum emitters that achieves polynomial scaling in construction time relative to photon collection efficiency, thereby enabling efficient distributed quantum tasks like secure two-party computation on near-term hardware without requiring deterministic photon collection.

Original authors: Maxwell Gold, Jianlong Lin, Eric Chitambar, Elizabeth A. Goldschmidt

Published 2026-08-21

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Maxwell Gold, Jianlong Lin, Eric Chitambar, Elizabeth A. Goldschmidt

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 computing promises to solve problems that are currently impossible for even the most powerful supercomputers, from designing new medicines to securing global communications. At the heart of this promise is a phenomenon called entanglement, where particles become so deeply linked that the state of one instantly influences the other, regardless of the distance between them. To harness this power, scientists often need to create vast, intricate webs of these linked particles, known as graph states. In the realm of light-based quantum computing, these webs are built from individual photons, the tiny packets of light that carry information. The challenge has long been that building these webs requires a machine that can catch and hold every single photon it creates with perfect reliability. If even one photon is lost in the process, the entire structure collapses, forcing the computer to start over from scratch. For years, this requirement for perfection has kept large-scale quantum networks out of reach, as the best light sources available today still lose a significant number of photons.

A team of researchers at the University of Illinois Urbana-Champaign has now proposed a new way to build these quantum webs that works even when the light source is imperfect. Instead of demanding that every photon be caught immediately, they developed a method they call "emit-then-add." In this approach, the system generates a photon and waits to confirm it has been successfully collected before attaching it to the growing network. If the photon is lost, the system simply tries again without disturbing the part of the network that has already been built. This simple shift in strategy changes the rules of the game. While previous methods would take an exponentially longer time to build a larger network as the size increased, this new method scales much more gently, requiring only a polynomial increase in time. This means that with current technology, which struggles to catch every photon, scientists can now realistically build the large, complex quantum states needed for powerful computations.

The researchers demonstrated that this technique requires only a small amount of extra hardware: one additional memory unit to store the quantum information and a few extra operations for each photon added. Crucially, they showed that for many important tasks, such as performing secure calculations, the system does not even need to store the photons in a special memory bank while waiting. Instead, the photons can be measured and used immediately, provided the measurement happens in a specific order. This allows the creation of what the authors call a "virtual" graph state, a massive network of entangled particles that never actually exist all at the same time. The network is built, used, and measured in a flowing sequence, bypassing the need for the difficult-to-achieve technology of storing light for long periods.

To prove the practical value of this discovery, the team designed a specific protocol for secure two-party computation, a scenario where two people want to calculate a result together without revealing their private inputs to each other or to a third party acting as a referee. Using their new method, they showed that this secure calculation could be performed efficiently on current hardware. The protocol relies on a small, fixed-size quantum state of twelve photons, which can be generated repeatedly and distributed to the participants. Even with the imperfections of today's light sources, the system can correct for errors and maintain security. The researchers estimate that with the best available quantum emitters, this approach could handle inputs of significant size, opening the door to real-world secure quantum applications that were previously thought impossible.

The significance of this work lies in its compatibility with the imperfect reality of current technology. Most existing proposals for quantum networks assume a level of efficiency that simply does not exist yet, making them impractical for near-term use. By accepting that photons will be lost and designing a system that can recover from those losses without starting over, the researchers have removed a major bottleneck. Their method shifts the limiting factor from the ability to catch light to the ability to keep quantum information stable over time, a challenge that current systems are much better equipped to handle. This suggests that the path to powerful quantum networks may not require waiting for perfect light sources, but rather for smarter ways to use the imperfect ones we already have.

Technical Summary: Heralded Photonic Graph States with Inefficient Quantum Emitters

Problem Statement
The generation of photonic graph states is a critical resource for measurement-based quantum computation (MBQC) and distributed quantum communication. Current deterministic schemes for generating these states rely on the assumption that every excitation of a quantum emitter results in a successfully collected and detected photon. However, state-of-the-art coherent quantum emitters (such as trapped ions, neutral atoms, and quantum dots) often suffer from poor photon collection efficiencies ( $\eta_e \ll 1$ ). In deterministic protocols, any failure to detect a photon necessitates restarting the entire protocol, causing the construction time for a graph of size $n_p$ to scale exponentially as $O(\eta_e^{-n_p})$ . This exponential scaling renders the generation of moderately sized graph states (10–100 photons) impractical on near-term hardware.

Methodology: "Emit-Then-Add"
The authors propose a heralded scheme termed "emit-then-add" to circumvent the limitations of inefficient photon collection. The core methodology involves decoupling the role of the emitter into two distinct components:

An Emitting Spin: Optimized for fast, high-fidelity photon generation and readout.
Auxiliary Spin Qubits: Optimized for long coherence times, used to store quantum information and entangle with the graph.

The protocol operates as follows:

The emitting spin is excited to produce a photon entangled with its internal state.
The photon is collected with efficiency $\eta_e$ .
Heralding: A detection event (herald) confirms the photon's presence. If detection fails, the emitting spin is simply reinitialized, and the attempt is repeated without disturbing the graph state currently under construction.
Addition: Upon successful heralding, the quantum information (entanglement) is transferred from the emitting spin to an auxiliary spin via a local two-qubit spin-spin entangling gate. The emitting spin is then measured and reset for the next iteration.
Virtual Graph States: For many applications, including MBQC, the authors demonstrate that non-destructive (Quantum Non-Demolition, QND) measurement is not strictly required. Instead, photons can be destructively measured immediately upon generation if the measurement basis is determined prior to emission. This allows for the construction of "virtual" graph states where photons do not need to exist simultaneously, eliminating the need for long-duration photonic storage.

Key Contributions

Polynomial Scaling: The primary theoretical contribution is the demonstration that the construction time for large graph states scales polynomially, $O(n_p \eta_e^{-1})$ , rather than exponentially. This is achieved because failed collection events only reset the emitter, not the entire graph.
Resource Overhead Analysis: The scheme requires minimal additional overhead compared to deterministic methods: one extra spin qubit and one additional spin-spin entangling gate (plus a mid-circuit measurement and reset) per photon added to the graph.
Fidelity and Coherence Trade-offs: The authors analyze the fidelity constraints, noting that while the scheme relaxes the requirement for high photon collection efficiency, it shifts the bottleneck to the coherence time ( $\tau$ ) of the auxiliary spins. The auxiliary spins must remain coherent for the duration of the entire graph construction, which is significantly longer than the time required in deterministic schemes.
Application to Secure Two-Party Computation: The paper presents a specific use case: a protocol for secure multi-party computation (MPC) that computes arbitrary Boolean functions. This protocol utilizes distributed 12-qubit graph states. Crucially, it requires only two rounds of public communication and does not require photonic memory, making it compatible with current hardware constraints.

Results and Performance Estimates

Scaling Comparison: Simulations (Fig. 2) show that for collection efficiencies $\eta_e \in \{0.1, 0.5, 0.9\}$ , the "emit-then-add" scheme allows for the construction of 10–100 photon graph states on realistic timescales, whereas deterministic schemes fail to do so due to exponential time penalties.
Fidelity Constraints: The scheme introduces infidelities associated with the additional entangling gates and mid-circuit measurements, captured by a parameter $F_{add}$ . The authors estimate that with current state-of-the-art trapped ion and neutral atom systems (offering second-scale coherence times), graph states of 10–100 photons can be generated with fidelities sufficient for computation, provided $F_{add}$ is high (e.g., 0.99).
MPC Protocol: The proposed two-party computation protocol is shown to be secure against arbitrary malicious adversaries (in the simulation-based security model) and can be implemented efficiently. The computation rate is estimated to be viable even with pessimistic error assumptions (e.g., $\eta_e = 0.1$ and $F_{add} = 0.99$ ), allowing for error-corrected computation with minimal reduction in overall rate.

Significance and Claims
The paper claims that the "emit-then-add" paradigm represents a significant shift in the feasibility of photonic quantum computing on near-term hardware. By accepting a modest increase in spin-qubit overhead and gate operations, the scheme removes the exponential barrier imposed by imperfect photon collection. The authors assert that this approach enables the generation of large entangled photonic states limited primarily by spin decoherence rather than collection efficiency. They further claim that their specific application to secure two-party computation demonstrates a practical pathway to implementing useful quantum protocols using current or near-term quantum emitter platforms without the need for advanced photonic memory or near-unity collection efficiencies.

More like this