Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:1108.5571 · Physical Review Letters

Blind Quantum Computing with Weak Coherent Pulses

Vedran Dunjko, Elham Kashefi, Anthony Leverrier

Published May 18, 2012• 115 citations
arXivHTMLPDF

Abstract

The universal blind quantum computation (UBQC) protocol [A. Broadbent, J. Fitzsimons, and E. Kashefi, in Proceedings of the 50th Annual IEEE Symposiumon Foundations of Computer Science (IEEE Computer Society, Los Alamitos, CA, USA, 2009), pp. 517-526.] allows a client to perform quantum computation on a remote server. In an ideal setting, perfect privacy is guaranteed if the client is capable of producing specific, randomly chosen single qubit states. While from a theoretical point of view, this may constitute the lowest possible quantum requirement, from a pragmatic point of view, generation of such states to be sent along long distances can never be achieved perfectly. We introduce the concept of ϵ blindness for UBQC, in analogy to the concept of ϵ security developed for other cryptographic protocols, allowing us to characterize the robustness and security properties of the protocol under possible imperfections. We also present a remote blind single qubit preparation protocol with weak coherent pulses for the client to prepare, in a delegated fashion, quantum states arbitrarily close to perfect random single qubit states. This allows us to efficiently achieve ϵ-blind UBQC for any ϵ>0, even if the channel between the client and the server is arbitrarily lossy.

DOI
10.1103/physrevlett.108.200502

Related papers

Blind Quantum Computing with Decoy States

Xu, Ke, Hoi‐Kwong Lo

In this paper, we study the Universal Blind Quantum Computing (UBQC) protocol, which allows a client to perform quantum computation on a remote quantum server and the Remote Blind qubit state Preparation (RBSP) protocol which allows the client to prepare single qubits on the server's location with week coherent pulses. This RBSP protocol is inefficient for small $ T $, because the required number of pulses for generating one single qubit scales as $ \mbox{O}(1/T^4) $, where $ T $ is the transmittance of the quantum channe between the client and the server. Our contribution in this paper is a modified RBSP protocol with decoy states. This new protocol allows us to generate $ S $ single qubits simultaneously in a single instance. With our new rotocol, we are able to reduce the number of weak coherent pulses required for generating one single qubit from $ \mbox{O}(1/T^4) $ to nearly $ \mbox{O}(1/T) $, significantly increasing the efficiency. For a 100 km standard telecom fiber of loss 0.2 dB/km, our method gives a six orders of magnitude improvement in the speed, which is very significant.

arXiv:1508.07910•Aug 31, 2015•3 citations

Optimal Blind Quantum Computation

Atul Mantri, Carlos A. Pérez-Delgado, Joseph F. Fitzsimons

Blind quantum computation allows a client with limited quantum capabilities to interact with a remote quantum computer to perform an arbitrary quantum computation, while keeping the description of that computation hidden from the remote quantum computer. While a number of protocols have been proposed in recent years, little is currently understood about the resources necessary to accomplish the task. Here, we present general techniques for upper and lower bounding the quantum communication necessary to perform blind quantum computation, and use these techniques to establish concrete bounds for common choices of the client's quantum capabilities. Our results show that the universal blind quantum computation protocol of Broadbent, Fitzsimons, and Kashefi, comes within a factor of 8/3 of optimal when the client is restricted to preparing single qubits. However, we describe a generalization of this protocol which requires exponentially less quantum communication when the client has a more sophisticated device.

arXiv:1306.3677•Physical Review Letters•Dec 3, 2013•88 citations

Universal blind quantum computation with improved brickwork states

Shuquan Ma, Changhua Zhu, Xuchao Liu +2 more

Universal blind quantum computation allows a client who has limited quantum abilities to delegate his or her private computation to an untrusted quantum server. The first universal blind quantum computation protocol was proposed by Broadbent, Fitzsimons, and Kashefi. In their work the computation resource is the so-called brickwork state, which can be constructed by a number of specific single qubits. The number of single qubits is in theory linearly related to the size of the quantum circuit. However, due to the fixed structure of the brickwork states, the actual number of qubits is usually far more than the linear size. In this work we mainly construct three improved brickwork states whose structures are no longer fixed, thus they can efficiently reduce the client's qubit consumption. Using those improved brickwork states we propose a class of efficient universal blind quantum computation protocols. In our basic protocol, to implement a single-qubit basic gate the client needs to prepare only two ancillary qubits, while in the original protocol it will consume four ancillary qubits. Making use of our improved brickwork states the qubit consumption of implementing a nonadjacent two-qubit gate such as a control-$X$ gate can be sharply reduced.

Physical Review A•Jan 4, 2024•15 citations

Garbled Quantum Computation

Elham Kashefi, Petros Wallden

The universal blind quantum computation protocol (UBQC) enables an almost classical client to delegate a quantum computation to an untrusted quantum server (in the form of a garbled quantum circuit) while the security for the client is unconditional. In this contribution, we explore the possibility of extending the verifiable UBQC, to achieve further functionalities following the analogous research for classical circuits (Yao 1986). First, exploring the asymmetric nature of UBQC (the client preparing only single qubits, while the server runs the entire quantum computation), we present a “Yao”-type protocol for secure two-party quantum computation. Similar to the classical setting, our quantum Yao protocol is secure against a specious (quantum honest-but-curious) garbler, but in our case, against a (fully) malicious evaluator. Unlike the previous work on quantum two-party computation of Dupuis et al., 2010, we do not require any online-quantum communication between the garbler and the evaluator and, thus, no extra cryptographic primitive. This feature will allow us to construct a simple universal one-time compiler for any quantum computation using one-time memory, in a similar way to the classical work of Goldwasser et al., 2008, while more efficiently than the previous work of Broadbent et al., 2013.

arXiv:1606.06931•Cryptography•Apr 7, 2017•19 citations

Fault-tolerant verifiable blind quantum computing with logical state remote preparation

Yuki Takeuchi, Keisuke Fujii, Tomoyuki Morimae +1 more

Verifiable blind quantum computing allows a client with poor quantum devices to delegate universal quantum computing to a remote quantum server in such a way that the client's privacy is protected and the honesty of the server is verified. In existing protocols, the client has to send single-qubit states to the server. These states might be decohered by the channel noise. Furthermore, the client hides some "trap" qubits in the server's register so that the client can detect the server's deviation. In reality, however, these trap qubits are disturbed by imperfect operations by the server, which reduces the probability that the client accepts the honest server. To solve these problems, we propose a new gadget that allows the client to remotely prepare encoded logical single-qubit states in the server's place. Importantly, in our fault-tolerant verifiable blind quantum computing protocol, the client needs only the ability of physical single-qubit measurements in $X$ and $Z$ bases.

arXiv:1607.01568•Jul 6, 2016•4 citations

Unconditionally verifiable blind quantum computation

Joseph F. Fitzsimons, Elham Kashefi

Blind quantum computing (BQC) allows a client to have a server carry out a quantum computation for them such that the client's input, output, and computation remain private. A desirable property for any BQC protocol is verification, whereby the client can verify with high probability whether the server has followed the instructions of the protocol or if there has been some deviation resulting in a corrupted output state. A verifiable BQC protocol can be viewed as an interactive proof system leading to consequences for complexity theory. We previously proposed [A. Broadbent, J. Fitzsimons, and E. Kashefi, in Proceedings of the 50th Annual Symposium on Foundations of Computer Science, Atlanta, 2009 (IEEE, Piscataway, 2009), p. 517] a universal and unconditionally secure BQC scheme where the client only needs to be able to prepare single qubits in separable states randomly chosen from a finite set and send them to the server, who has the balance of the required quantum computational resources. In this paper we extend that protocol with additional functionality allowing blind computational basis measurements, which we use to construct another verifiable BQC protocol based on a different class of resource states. We rigorously prove that the probability of failing to detect an incorrect output is exponentially small in a security parameter, while resource overhead remains polynomial in this parameter. This resource state allows entangling gates to be performed between arbitrary pairs of logical qubits with only constant overhead. This is a significant improvement on the original scheme, which required that all computations to be performed must first be put into a nearest-neighbor form, incurring linear overhead in the number of qubits. Such an improvement has important consequences for efficiency and fault-tolerance thresholds.

arXiv:1203.5217•Physical Review A•Jul 5, 2017•281 citations
The universal blind quantum computation (UBQC) protocol [A. Broadbent, J. Fitzsimons, and E. Kashefi, in Proceedings of the 50th Annual IEEE Symposiumon Foundations of Computer Science (IEEE Computer Society, Los Alamitos, CA, USA, 2009), pp. 517-526.] allows a client to perform quantum computation on a remote server. In an ideal setting, perfect privacy is guaranteed if the client is capable of producing specific, randomly chosen single qubit states. While from a theoretical point of view, this may constitute the lowest possible quantum requirement, from a pragmatic point of view, generation of such states to be sent along long distances can never be achieved perfectly. We introduce the concept of ϵ blindness for UBQC, in analogy to the concept of ϵ security developed for other cryptographic protocols, allowing us to characterize the robustness and security properties of the protocol under possible imperfections. We also present a remote blind single qubit preparation protocol with weak coherent pulses for the client to prepare, in a delegated fashion, quantum states arbitrarily close to perfect random single qubit states. This allows us to efficiently achieve ϵ-blind UBQC for any ϵ>0, even if the channel between the client and the server is arbitrarily lossy.
In this paper, we study the Universal Blind Quantum Computing (UBQC) protocol, which allows a client to perform quantum computation on a remote quantum server and the Remote Blind qubit state Preparation (RBSP) protocol which allows the client to prepare single qubits on the server's location with week coherent pulses. This RBSP protocol is inefficient for small $ T $, because the required number of pulses for generating one single qubit scales as $ \mbox{O}(1/T^4) $, where $ T $ is the transmittance of the quantum channe between the client and the server. Our contribution in this paper is a modified RBSP protocol with decoy states. This new protocol allows us to generate $ S $ single qubits simultaneously in a single instance. With our new rotocol, we are able to reduce the number of weak coherent pulses required for generating one single qubit from $ \mbox{O}(1/T^4) $ to nearly $ \mbox{O}(1/T) $, significantly increasing the efficiency. For a 100 km standard telecom fiber of loss 0.2 dB/km, our method gives a six orders of magnitude improvement in the speed, which is very significant.
Blind quantum computation allows a client with limited quantum capabilities to interact with a remote quantum computer to perform an arbitrary quantum computation, while keeping the description of that computation hidden from the remote quantum computer. While a number of protocols have been proposed in recent years, little is currently understood about the resources necessary to accomplish the task. Here, we present general techniques for upper and lower bounding the quantum communication necessary to perform blind quantum computation, and use these techniques to establish concrete bounds for common choices of the client's quantum capabilities. Our results show that the universal blind quantum computation protocol of Broadbent, Fitzsimons, and Kashefi, comes within a factor of 8/3 of optimal when the client is restricted to preparing single qubits. However, we describe a generalization of this protocol which requires exponentially less quantum communication when the client has a more sophisticated device.
Universal blind quantum computation allows a client who has limited quantum abilities to delegate his or her private computation to an untrusted quantum server. The first universal blind quantum computation protocol was proposed by Broadbent, Fitzsimons, and Kashefi. In their work the computation resource is the so-called brickwork state, which can be constructed by a number of specific single qubits. The number of single qubits is in theory linearly related to the size of the quantum circuit. However, due to the fixed structure of the brickwork states, the actual number of qubits is usually far more than the linear size. In this work we mainly construct three improved brickwork states whose structures are no longer fixed, thus they can efficiently reduce the client's qubit consumption. Using those improved brickwork states we propose a class of efficient universal blind quantum computation protocols. In our basic protocol, to implement a single-qubit basic gate the client needs to prepare only two ancillary qubits, while in the original protocol it will consume four ancillary qubits. Making use of our improved brickwork states the qubit consumption of implementing a nonadjacent two-qubit gate such as a control-XXX gate can be sharply reduced.
The universal blind quantum computation protocol (UBQC) enables an almost classical client to delegate a quantum computation to an untrusted quantum server (in the form of a garbled quantum circuit) while the security for the client is unconditional. In this contribution, we explore the possibility of extending the verifiable UBQC, to achieve further functionalities following the analogous research for classical circuits (Yao 1986). First, exploring the asymmetric nature of UBQC (the client preparing only single qubits, while the server runs the entire quantum computation), we present a “Yao”-type protocol for secure two-party quantum computation. Similar to the classical setting, our quantum Yao protocol is secure against a specious (quantum honest-but-curious) garbler, but in our case, against a (fully) malicious evaluator. Unlike the previous work on quantum two-party computation of Dupuis et al., 2010, we do not require any online-quantum communication between the garbler and the evaluator and, thus, no extra cryptographic primitive. This feature will allow us to construct a simple universal one-time compiler for any quantum computation using one-time memory, in a similar way to the classical work of Goldwasser et al., 2008, while more efficiently than the previous work of Broadbent et al., 2013.
Verifiable blind quantum computing allows a client with poor quantum devices to delegate universal quantum computing to a remote quantum server in such a way that the client's privacy is protected and the honesty of the server is verified. In existing protocols, the client has to send single-qubit states to the server. These states might be decohered by the channel noise. Furthermore, the client hides some "trap" qubits in the server's register so that the client can detect the server's deviation. In reality, however, these trap qubits are disturbed by imperfect operations by the server, which reduces the probability that the client accepts the honest server. To solve these problems, we propose a new gadget that allows the client to remotely prepare encoded logical single-qubit states in the server's place. Importantly, in our fault-tolerant verifiable blind quantum computing protocol, the client needs only the ability of physical single-qubit measurements in XXX and ZZZ bases.
Blind quantum computing (BQC) allows a client to have a server carry out a quantum computation for them such that the client's input, output, and computation remain private. A desirable property for any BQC protocol is verification, whereby the client can verify with high probability whether the server has followed the instructions of the protocol or if there has been some deviation resulting in a corrupted output state. A verifiable BQC protocol can be viewed as an interactive proof system leading to consequences for complexity theory. We previously proposed [A. Broadbent, J. Fitzsimons, and E. Kashefi, in Proceedings of the 50th Annual Symposium on Foundations of Computer Science, Atlanta, 2009 (IEEE, Piscataway, 2009), p. 517] a universal and unconditionally secure BQC scheme where the client only needs to be able to prepare single qubits in separable states randomly chosen from a finite set and send them to the server, who has the balance of the required quantum computational resources. In this paper we extend that protocol with additional functionality allowing blind computational basis measurements, which we use to construct another verifiable BQC protocol based on a different class of resource states. We rigorously prove that the probability of failing to detect an incorrect output is exponentially small in a security parameter, while resource overhead remains polynomial in this parameter. This resource state allows entangling gates to be performed between arbitrary pairs of logical qubits with only constant overhead. This is a significant improvement on the original scheme, which required that all computations to be performed must first be put into a nearest-neighbor form, incurring linear overhead in the number of qubits. Such an improvement has important consequences for efficiency and fault-tolerance thresholds.