⚛️ quantum physics

Unifying communication paradigms in measurement-based delegated quantum computing

This paper unifies the "prepare-and-send" and "receive-and-measure" paradigms in delegated quantum computing by demonstrating how to translate protocols between these settings and construct new ones, thereby clarifying whether their distinct theoretical constraints are inevitable.

Original authors: Fabian Wiesner, Jens Eisert, Anna Pappa

Published 2026-03-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Fabian Wiesner, Jens Eisert, Anna Pappa

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 have a brilliant idea for a complex calculation, but you don't own a supercomputer. In fact, you don't even own a calculator. You only have a tiny, basic device. You want to hire a "Quantum Cloud" (a powerful quantum computer owned by someone else) to do the math for you.

But there's a catch: You don't trust the cloud owner.

You need two things:

Blindness: The owner shouldn't know what you are calculating or what your secret data is.
Verifiability: You need to be sure the owner didn't just guess the answer or cheat.

This is the world of Delegated Quantum Computing (DQC).

The Two Ways to Send a Package

For years, scientists have been trying to figure out the best way to send your "quantum package" to the cloud. There are two main methods, like two different ways to mail a letter:

The "Prepare-and-Send" (PS) Method: You (the client) pack the box (prepare the quantum bits), seal it, and mail it to the server. The server opens it, does the work, and sends the result back.
- Analogy: You are a chef who prepares the ingredients and sends them to a restaurant kitchen. The kitchen cooks the meal.
The "Receive-and-Measure" (RM) Method: The server packs the box and sends it to you. You open it, check the contents, and send back instructions on how to process it.
- Analogy: The restaurant sends you a pre-made meal kit. You taste it, check if it's good, and tell them how to finish the recipe.

The Problem: Two Separate Worlds

Until now, scientists treated these two methods as completely separate worlds.

If you wanted to use the PS method, you had a specific set of rules and security tricks.
If you wanted to use the RM method, you had a different set of rules.

It was like having two different languages for the same job. If a brilliant security trick was invented for the "Chef" (PS), it didn't automatically work for the "Taster" (RM). This made it hard to build flexible, future-proof quantum systems because we didn't know if one method was inherently safer or if they were actually just two sides of the same coin.

The Big Breakthrough: The Universal Translator

This paper, by Fabian Wiesner, Jens Eisert, and Anna Pappa, acts as a Universal Translator. They proved that these two methods are actually interchangeable.

They took the three main "building blocks" needed to make quantum computing secure and blind, and they showed how to translate every single one from one language to the other.

Here are the three blocks they translated:

1. The "Blindfold" (Blindness)

The Goal: Hiding your secret recipe.
The Translation: They showed that the tricks used to hide data when sending ingredients (PS) work just as well when receiving and tasting them (RM). You can achieve the same level of secrecy in both scenarios.

2. The "Trap" (Verification)

The Goal: Catching a cheater.
The Analogy: Imagine you send a cake to a baker. You hide a few "trap" ingredients (like a tiny, invisible bell) inside the batter. If the baker tries to eat the cake before baking it, the bell rings, and you know they cheated.
The Translation:
- In the PS world, scientists had already figured out how to hide these traps in the ingredients they sent.
- In the RM world, scientists had figured out how to hide traps in the meal kits they received.
- The Paper's Magic: They took the "Trap" method from the PS world and successfully built it into the RM world (and vice-versa for a different type of trap called "Stabilizer Testing"). They proved you can catch a cheater just as effectively whether you are the sender or the receiver.

3. The "Group Prep" (Collective Remote State Preparation)

The Goal: Multiple people working together to prepare a secret state.
The Translation: They showed how a group of clients can collaborate to prepare a quantum state in the "Receive-and-Measure" setting, a task that was previously only possible in the "Prepare-and-Send" setting.

Why Does This Matter?

Think of it like building a house.

Before this paper, architects thought you could only build houses with Bricks (PS) OR Wood (RM). If you wanted a specific feature (like a secret vault), you had to design it specifically for Bricks. If you switched to Wood, you had to start over.
This paper says: "Actually, Bricks and Wood are the same material, just shaped differently. If you know how to build a secret vault with Bricks, you can build the exact same vault with Wood, and it will be just as secure."

The Takeaway

This research unifies the field. It means:

Flexibility: Engineers can now choose the hardware that works best for them (light particles vs. solid chips) without worrying that they are losing security features.
Innovation: If someone invents a new security trick for one method, we now know exactly how to apply it to the other.
Future-Proofing: As quantum computers become real, we won't be stuck with one rigid way of doing things. We can mix and match, ensuring that the "Quantum Cloud" remains secure, blind, and verifiable, no matter how the technology evolves.

In short, they took two separate paths to the same destination and built a bridge between them, proving that in the quantum world, how you send the message doesn't change the truth of the message.

1. Problem Statement

Delegated Quantum Computing (DQC) allows clients with limited quantum resources to outsource computations to a powerful quantum server. A critical requirement for DQC is blindness (the server learns nothing about the input or computation) and verifiability (the client can verify the server's output).

Most DQC protocols operate within the Measurement-Based Quantum Computing (MBQC) framework, which involves three stages: preparing qubits, entangling them to form a resource state, and measuring them to run the computation. Currently, DQC research has split into two distinct communication paradigms:

Prepare-and-Send (PS): The client prepares single-qubit states and sends them to the server.
Receive-and-Measure (RM): The server prepares the resource state, and the client receives qubits to measure them.

The Core Problem: While both paradigms achieve similar goals, they have been studied independently. It remains unclear whether the theoretical constraints and cryptographic techniques specific to one setting are inevitable or if they can be translated to the other. This lack of equivalence limits the flexibility of protocol design and experimental implementation, as different hardware platforms (e.g., photonic vs. solid-state) favor different settings.

2. Methodology

The authors employ a modular approach using the Abstract Cryptography (AC) framework. This framework allows for the definition of security via the indistinguishability of a real protocol from an ideal resource, ensuring composable security.

The methodology involves:

Decomposition: Breaking down modern DQC protocols into three fundamental building blocks:
- Sblind: Single-client blind DQC.
- Sver: Single-client verifiable DQC.
- RSP: Collective Remote State Preparation.
Gap Analysis: Identifying which building blocks have been implemented in PS, which in RM, and where gaps exist.
Translation and Implementation:
- Providing missing implementations for specific building blocks in the "opposite" setting.
- Proving that these new implementations are equivalent to their counterparts in terms of security (using simulators to show indistinguishability).
- Demonstrating that the choice of setting (PS vs. RM) does not impose inherent theoretical limitations on security.

3. Key Contributions

The paper provides the missing implementations to unify the PS and RM settings, effectively proving they are interchangeable for DQC protocols.

A. Trap-Based Verification in Receive-and-Measure (RM)

Context: Optimized trap-based verification (using "dummy" nodes to isolate "trap" nodes) was well-established in PS (e.g., Broadbent et al., Kapourniotis et al.) but lacked a direct, efficient RM equivalent. Previous RM attempts (Morimae) required complex pre-computations to isolate traps.
Contribution: The authors propose Protocol 1, an RM version of the optimized trap-based verification.
- Mechanism: The client receives the resource state, measures dummy nodes in the $Z$ -basis (effectively "breaking" edges in the graph state), and measures trap nodes in the $X$ -basis.
- Result: This achieves 8/9 stand-alone verifiability without requiring pre-computation to split the resource state, matching the efficiency of PS protocols.

B. Stabilizer Testing in Prepare-and-Send (PS)

Context: Stabilizer testing (verifying the resource state via stabilizer measurements) is native to RM (e.g., Morimae & Fujii) because the client measures the state. It was unclear how to implement this in PS, where the client prepares the state and the server measures.
Contribution: The authors translate stabilizer testing to the PS setting.
- Mechanism: They derive an equivalence where the client prepares specific states (eigenstates of $X, Y, Z$ ) and delegates blind $X$ -measurements to the server. By analyzing the parity of measurement outcomes and preparation choices, the client can verify the stabilizer condition.
- Result: This proves that stabilizer-based verification is possible in PS with zero security loss ( $\epsilon=0$ ) compared to RM.

C. Collective Remote State Preparation (RSP) in RM

Context: Collective RSP (multiple clients preparing a state on a server) was previously only implemented in PS.
Contribution: The authors propose Protocol 2, an RM implementation of Collective RSP.
- Mechanism: The server prepares entangled registers. Clients measure their registers and send classical corrections to a designated client ( $C_k$ ), who computes a global correction $\delta$ and sends it to the server.
- Result: This perfectly implements the ideal RSP resource in the RM setting, provided at least one client is honest.

4. Results

Equivalence of Paradigms: The paper demonstrates that for any DQC protocol composed of the three identified building blocks (Blindness, Verification, RSP), an equivalent protocol exists in the alternative communication setting with the same level of security.
Security Proofs:
- Trap-based (RM): Proven 8/9 stand-alone verifiable; composable security follows via reduction.
- Stabilizer (PS): Proven to have the same security guarantees as RM counterparts.
- Collective RSP (RM): Proven to achieve perfect indistinguishability ( $\epsilon=0$ ) against any coalition of dishonest clients and/or the server, as long as the designated client $C_k$ is honest.
Table 1 Summary: The paper fills the gaps in the literature, showing that previously "missing" versions of protocols (e.g., Trap-based in RM, Stabilizer in PS, Collective RSP in RM) are now available.

5. Significance

Hardware Agnosticism: By unifying the paradigms, researchers and experimentalists can choose the communication setting (PS or RM) based on their available hardware (e.g., photonic sources for PS vs. solid-state qubits for RM) without sacrificing security or functionality.
Protocol Flexibility: It enables the development of hybrid communication settings, where different clients in a multi-party computation might use different paradigms (e.g., one prepares, another measures) to delegate a joint task.
Theoretical Clarity: It resolves the open question of whether setting-dependent constraints are inevitable, concluding that they are not. The security of DQC relies on the cryptographic building blocks, not the direction of communication.
Future Research: The work opens avenues for translating device-independent protocols (where client devices are untrusted) between settings and exploring semi-classical implementations (using weak coherent pulses) across both paradigms.

In conclusion, this paper provides the theoretical and practical bridge between the two dominant DQC communication models, ensuring that the field can advance with greater flexibility in both protocol design and experimental realization.