⚛️ quantum physics

Remotely Preparing Many Qubits with a Single Photon

This paper proposes a reflection-based Remote State Preparation (RSP) protocol that leverages a single photon in a superposition of $d$ modes to simultaneously encode and remotely prepare multiple qubits, achieving high success rates and fidelities while reducing phase stabilization requirements and bypassing qubit lifetime limitations.

Original authors: Tzula B. Propp, Benedikt Tissot, Anders S. Sørensen, Stephanie D. C. Wehner

Published 2026-04-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Tzula B. Propp, Benedikt Tissot, Anders S. Sørensen, Stephanie D. C. Wehner

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

Imagine you are trying to send a secret message to a friend who is far away. In the world of quantum computing, this "message" isn't just a letter; it's a set of instructions for building a complex machine (a quantum computer) that only your friend has.

Usually, to send these instructions, you have to send one tiny piece of information (a "qubit") at a time. It's like trying to build a house by mailing one brick at a time. If the mail takes too long, the bricks might get wet (decohere) or break before they arrive, and the house never gets built.

This paper introduces a clever new way to send the instructions: Instead of mailing one brick at a time, you mail a single, magical envelope that contains the blueprint for the entire house at once.

Here is a breakdown of how this works, using simple analogies:

1. The Magic Envelope (The Single Photon)

In physics, light comes in tiny packets called photons. Usually, a photon is just a single particle. But in this experiment, the scientists use a photon that is in a "superposition."

The Analogy: Imagine a photon is a single drop of water. Normally, it falls in one spot. But in this experiment, the drop of water is magically stretched out so that it exists in many different places at the same time (specifically, in different "time slots" or moments).

The paper calls this a qudit. Think of it like a single coin that is spinning so fast it looks like a blur, simultaneously showing "Heads," "Tails," and every angle in between. This single "blurry coin" can hold a massive amount of information.

2. The Remote Construction Site (The Server)

Your friend (the "Server") has a row of empty slots (qubits) waiting to be filled. They are like empty molds for a cake.

The Old Way: You send a messenger with a recipe for one cake layer. The messenger arrives, you fill one mold, then send another messenger for the next layer. If the first layer sits out too long, it dries out.
The New Way (R-RSP): You send one super-fast messenger carrying a recipe for all the layers at once.

3. The "Reflection" Trick

How does one photon tell 8 (or more) different molds what to do?

The scientists use a clever setup involving mirrors and switches.

The photon travels through a series of time-slots (like a train of cars).
As the photon passes, it interacts with the server's qubits.
The Magic Switch: If the photon is in "Time Slot 1," it might flip the switch on Qubit A. If it's in "Time Slot 2," it flips Qubit B. If it's in "Time Slot 3," it flips both.
By carefully arranging the timing, a single photon can perform a complex dance, flipping the switches on specific qubits based on which "time slot" it is currently in.

It's like a single conductor walking down a line of musicians. Depending on which musician he taps, that musician plays a different note. The conductor (the photon) only walks down the line once, but he directs the whole orchestra.

4. The "Herald" (The Success Signal)

The most amazing part is how they know it worked.

The Problem: In quantum mechanics, you can't just look at the system to see if it worked, because looking changes it.
The Solution: The photon eventually reaches a detector at the end of the line. When the detector clicks, it's like a "Herald" (a town crier) shouting, "Success! The house is built!"
Because the photon was in a superposition of all time-slots, that single click confirms that all the qubits have been set up correctly at the exact same moment.

Why is this a Big Deal?

1. Speed vs. Memory (The "Wet Brick" Problem)
Quantum bits are fragile. If you wait too long between sending them, they lose their information (decoherence).

Old Method: Sending qubits one by one is slow. By the time you send the 10th qubit, the 1st one might have already "dried out."
New Method: You prepare all the qubits simultaneously. It's like pouring the concrete for the whole foundation at once. Even if the process takes a little longer to set up, the actual "building" happens instantly, saving the qubits from drying out.

2. Security (Blind Quantum Computing)
This is crucial for "Blind Quantum Computing," where a client wants to use a powerful quantum computer owned by someone else (like a cloud server) without the server knowing what the client is doing.

This new method allows the client to send the "secret angles" (the recipe) for the qubits without revealing them.
It's more secure and requires less perfect equipment (like ultra-stable lasers) than previous methods.

3. The Trade-off
Is there a catch? Yes. To hold all this information, the photon needs to be spread out over exponentially many time slots.

Analogy: To send a blueprint for a whole city in one envelope, the envelope has to be huge.
If you want to prepare 10 qubits, you need $2^{10}$ (1,024) time slots. If you want 20, you need over a million.
However, the paper shows that even with this "huge envelope," the system is still much faster and more reliable than sending 1,000 tiny envelopes one by one, especially over long distances.

Summary

The paper proposes a way to use one single photon to set up many quantum bits simultaneously. By stretching the photon out over time and using clever mirrors, they can "program" a remote quantum computer in a single instant. This solves the problem of fragile quantum memory drying out while waiting for instructions, paving the way for a faster, more secure, and scalable Quantum Internet.

1. Problem Statement

The paper addresses a critical scalability bottleneck in Blind Quantum Computing (BQC) and quantum networks: the resource demands of Remote State Preparation (RSP).

The Bottleneck: Verifiable BQC requires a client to privately prepare many single-qubit states ( $|+\theta\rangle$ ) on a remote server. Current protocols prepare these qubits sequentially (qubit-by-qubit).
The Challenge: In the era of Noisy Intermediate-Scale Quantum (NISQ) devices, qubits have limited coherence times. Sequential preparation forces qubits to wait in memory while subsequent qubits are prepared, leading to significant decoherence and fidelity loss.
The Goal: Develop a protocol that can prepare an $n$ -qubit product state simultaneously using minimal resources to bypass memory decoherence limits and improve success rates over long distances.

2. Methodology: Reflection-based RSP (R-RSP)

The authors propose a novel protocol called Reflection-based Remote State Preparation (R-RSP). The core innovation is using a single photon in a superposition of $2^n$ temporal modes (time-bins) to encode an $n$ -qubit state.

Key Mechanism

Resource State Generation:
- The server prepares an $n$ -qubit register in the state $|+\rangle^{\otimes n}$ .
- A photon is prepared in a superposition of $2^n$ time-bins: $|\psi\rangle = \sum_{x} c_x \hat{a}^\dagger_x |vac\rangle$ .
Conditional Phase Flip Interaction:
- The photon passes through an optical switch network where each time-bin $x$ (represented by a binary string $\vec{x}$ ) interacts with specific qubits in the register.
- If the $l$ -th bit of $\vec{x}$ is 1, the photon interacts with the $l$ -th qubit, implementing a conditional phase flip ( $|+\rangle \to |-\rangle$ ).
- This creates an entangled light-matter state: $|\Phi\rangle = \sum_{\vec{x}} c_x \hat{a}^\dagger_x |vac\rangle |\vec{x}\rangle$ .
Erasure and Heralding:
- "Which-time-bin" information is erased using a Quantum Fourier Transform (QFT) or a time lens.
- The client (or server) detects a single photon.
- Heralding: The detection of this single photon projects the $n$ -qubit register into the desired target state $|+\vec{\theta}\rangle = \bigotimes |+\theta_i\rangle$ , up to local phase corrections determined by the detection outcome.

Protocol Variations

The paper outlines 8 variations based on three choices:

Qubit Count: Single vs. Many qubits.
Light Source: Single-photon sources vs. Weak Coherent Pulses (WCPs).
Architecture: Emission-based (client sends) vs. Measurement-based (client receives).

3. Key Contributions

Quantum Speed-up in RSP: The protocol achieves a quantum speed-up by preparing $n$ qubits with a single transmission event, rather than $n$ sequential events.
Linear Scaling with Distance: Unlike sequential protocols where success probability scales exponentially with distance (due to $n$ transmissions), R-RSP success probability scales linearly with fiber transmission efficiency ( $\eta_t$ ) because only one photon is transmitted.
Relaxed Phase Stabilization: Compared to existing "single-click" emission protocols, R-RSP has significantly relaxed requirements for phase stabilization over long fibers, as the phase information is encoded in the relative phases of time-bins within a single pulse.
Security: The protocol inherits the security of existing schemes (like Double-Click RSP) when using WCPs, relying on the no-cloning theorem and quantum state teleportation principles.
Theoretical Proof of Necessity: The authors prove that $2^n$ temporal modes are mathematically required to deterministically encode $n$ arbitrary phases into an $n$ -qubit register using a single photon, based on Hilbert space dimension arguments.

4. Results

Single-Qubit Performance ( $n=1$ )

Trade-off: The R-RSP protocol achieves a rate-fidelity trade-off comparable to the best existing "Single-Click" (SC) protocols.
Advantage: It outperforms "Double-Click" (DC) protocols in low-efficiency regimes and offers the same performance as SC but without the stringent phase-stabilization requirements.

Many-Qubit Performance ( $n > 1$ )

Decoherence Mitigation: By preparing all $n$ qubits simultaneously, the protocol avoids the "window problem" where qubits decohere while waiting for others to be prepared.
Rate Improvement: Numerical simulations (for $n=8$ ) show that R-RSP offers orders of magnitude improvement in preparation rates over long distances compared to sequential DC-RSP.
Optimal Batch Size: There is an optimal batch size $k$ (qubits per photon) depending on distance and coherence time. For long distances, preparing many qubits in a single photon ( $k=n$ ) becomes the most efficient strategy despite the exponential increase in time-bins.
Asymptotic Scaling: In the limit of high loss, the rate scales as $R \propto \eta_t^q$ (where $q$ is the number of batches). For a single batch ( $q=1$ ), the rate scales linearly with transmission, whereas sequential protocols scale as $\eta_t^n$ .

5. Significance and Outlook

Enabling NISQ-era BQC: This protocol provides a viable path for Blind Quantum Computing on current NISQ devices where memory coherence is limited. It allows for the preparation of large entangled states (like brickwork graphs) before decoherence destroys them.
Quantum Multiplexing: The work demonstrates a form of quantum multiplexing where coherence between temporally multiplexed pulses provides a "beyond-classical" advantage in communication rates.
Hardware Agnostic: The protocol is compatible with various matter-photon interfaces (trapped atoms, quantum dots, diamond color centers) and can be implemented with current optical switching and time-lens technology.
Future Work: The authors note that a full security proof for $n > 1$ using WCPs (generalizing to qudits) remains an open challenge, and optimizing the "batch size" for specific hardware parameters is a practical engineering task.

In summary, the paper introduces a fundamental shift in remote state preparation, moving from sequential, memory-intensive processes to a parallel, single-photon approach that drastically improves scalability and fidelity for long-distance quantum networks.