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

Blind oracular quantum computation : from concept to physical implementation

Cica Gustiani

Published Jan 1, 2020• 1 citation
Publisher

Abstract

Recent years have seen much excitement for application of quantum computing, triggered by substantial — and ongoing — advances in experimental realizations of quantum computing. It is widely believed that client-server is the setting for quantum computers that will prevail in the future, where privacy becomes crucial in the application. Moreover, a recent experiment by Barz et al. [1] successfully demonstrated a blind quantum computation scheme: a client-server quantum computation in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing valuable details of the computation. In this thesis, we discuss the Blind Oracular Quantum Computation (BOQC) scheme, a blind quantum computing scheme in which a third party (the oracle)with limited quantum power, assists the execution of a client’s oracular quantum computations by implementing oracle evaluations. In BOQC, a client with limited quantum power and without the capacity to construct the oracle, can delegate her oracular quantum computations to a powerful yet untrustworthy server, with the help of the oracle. We show that BOQC is provably blind within a composable definition such that the server cannot learn about the clients’ computation. We provide a realization of BOQC in a physical setting, particularly in a diamond nitrogen-vacancy (NV) center platform. In BOQC, the server has a One-Way Quantum Computer (1WQC) that is resource-demanding. To lower the resource-requirements, we develop the BOQCo protocol, a BOQC that employs lazy 1WQC to minimize the number of qubits needed. We also provide systematic numerical optimization to find resource states that are BOQC-compatible by admitting BOQC security criteria. Finally, we give explicit oracular quantum algorithms that are BOQC-compatible to be executed on the NV-center platform. The algorithms include 2-qubit Grover’s algorithm using three qubits, 3-qubit exact Grover’s algorithm using four qubits, 2-qubit Simon’s algorithm with a useless oracle using four qubits, and Deutsch’s algorithm using three physical qubits. We hope that these BOQC algorithms intrigue some experimentalists to try to implement them.[1] S. Barz et al. “Demonstration of Blind Quantum Computing”. In: Science 335.6066 (2012), pp. 303–308.

DOI
10.18154/rwth-2021-01620

Related papers

Blind three-qubit exact Grover search on a nitrogen-vacancy-center platform

Cica Gustiani, David Peter Divincenzo

Here we put into practice the concept of blind client-server quantum computation, in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing any details of the computation. In particular, it is a three-node setting in which an oracular quantum computation can be executed blindly. In this Blind Oracular Quantum Computation (BOQC), the oracle (Oscar) is another node, with limited power, who acts in cooperation with the client (Alice) to supply quantum information to the server so that the oracle part of the quantum computation can also be executed blindly. We develop tests of this protocol using two- and three-qubit versions of the exact Grover algorithm (i.e., with database sizes $4\ensuremath{\le}N\ensuremath{\le}8$), obtaining optimal implementations of these algorithms within a gate array scheme and the blinded cluster-state scheme. We discuss the feasibility of executing these protocols in state-of-the-art three-node experiments using nitrogen-vacancy diamond electronic and nuclear qubits.

Physical Review A•Dec 14, 2021•6 citations

Blind oracular quantum computation

Cica Gustiani, David Peter Divincenzo

Abstract In the standard oracle model, an oracle efficiently evaluates an unknown classical function independent of the quantum algorithm itself. Quantum algorithms have a complex interrelationship to their oracles; for example the possibility of quantum speedup is affected by the manner by which oracles are implemented. Therefore, it is physically meaningful to separate oracles from their quantum algorithms, and we introduce one such separation here. We define the blind oracular quantum computation (BOQC) scheme, in which the oracle is a distinct node in a quantum network. Our work augments the client–server setting of quantum computing, in which a powerful quantum computer server is available on the network for discreet use by clients on the network with low quantum power. In BOQC, an oracle is another client that cooperates with the main client so that an oracular quantum algorithm is run on the server. The cooperation between the main client and the oracle takes place (almost) without communication. We prove BOQC to be blind: the server cannot learn anything about the clients’ computation. This proof is performed within the composable security definitions provided by the formalism of abstract cryptography. We enhance the BOQC scheme to be runnable with minimal physical qubits when run on a solid-state quantum network; we prove that this scheme, which we refer to as BOQCo (BOQC-optimized), possesses the same security as BOQC.

arXiv:2010.13840•Quantum Science and Technology•Jul 13, 2021•7 citations

Three-qubit exact Grover within the blind oracular quantum computation scheme

Cica Gustiani, David Peter Divincenzo

Here we extend the concept of blind client-server quantum computation, in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing any details of the computation. Our extension is to introduce a three-node setting in which an oracular quantum computation can be executed blindly. In this Blind Oracular Quantum Computation (BOQC), the oracle (Oscar) is another node, with limited power, who acts in cooperation with the client (Alice) to supply quantum information to the server so that the oracle part of the quantum computation can also be executed blindly. We develop tests of this protocol using two- and three-qubit versions of the exact Grover algorithm (i.e., with database sizes $4\leq N\leq 8$), obtaining optimal implementations of these algorithms within a gate array scheme and the blinded cluster-state scheme. We discuss the feasibility of executing these protocols in state-of-the-art three-node experiments using NV-diamond electronic and nuclear qubits.

arXiv:1902.05534•Feb 14, 2019•1 citation

Blind Quantum Computation on a Modular Superconducting Processor

Yongxin Song, Johannes Knörzer, Kieran Dalton +2 more

Current cloud-based quantum processors offer access to advanced hardware hosted on a remote server, but do not guarantee data or algorithm privacy. Blind quantum computation provides information-theoretic privacy by enabling a client to execute an algorithm without disclosing information about either the task or the final result. Here, we execute a measurement-based blind quantum computation protocol on a superconducting processor comprising two flip-chip-bonded modules, one acting as a server and the other as a client. The server generates a two-dimensional cluster state and forwards it to the client. Using this resource, the client implements a universal gate set with only adaptive single-qubit rotations and measurements. To illustrate this approach, we execute a three-qubit instance of the Deutsch-Jozsa algorithm. We analyze the server's quantum state after each rotation of a measurement-based single-qubit gate to verify that negligible information about the computation is revealed to the server, consistent with the one-way flow of information that guarantees blindness. This proof-of-principle demonstration establishes key elements of blind quantum computation in superconducting-circuit architectures, indicating that intermediate-scale implementations of blind protocols may become feasible with realistic near-term improvements in gate fidelities.

quant-pharXiv:2605.14656•May 15, 2026•0 citations

Demonstration of Blind Quantum Computing

Stefanie Barz, Elham Kashefi, Anne Broadbent +3 more

Quantum computers, besides offering substantial computational speedups, are also expected to preserve the privacy of a computation. We present an experimental demonstration of blind quantum computing in which the input, computation, and output all remain unknown to the computer. We exploit the conceptual framework of measurement-based quantum computation that enables a client to delegate a computation to a quantum server. Various blind delegated computations, including one- and two-qubit gates and the Deutsch and Grover quantum algorithms, are demonstrated. The client only needs to be able to prepare and transmit individual photonic qubits. Our demonstration is crucial for unconditionally secure quantum cloud computing and might become a key ingredient for real-life applications, especially when considering the challenges of making powerful quantum computers widely available.

arXiv:1110.1381•Science•Jan 19, 2012•473 citations

Verifiable blind quantum computing: Comparative analysis and design considerations for client architectures

Janice van Dam, Jeroen Grimbergen, Stephanie D. C. Wehner

Blind quantum computing (BQC) allows a client to delegate quantum computations to a remote server without revealing the input, computation, or output. In addition to being blind, the client can sometimes also verify that the server has performed their instructions correctly, a property known as verifiability. A key part of realizing such verifiable BQC (VBQC) is choosing the design of the client device: many architectures have been proposed, each with different hardware requirements, security properties, and performance characteristics, making it difficult to identify which is most suitable for a given implementation. In this work, we present a comparative analysis of client architectures for VBQC with a matter-qubit server. We restrict our analysis to single-server, single-client protocols with information-theoretic security based on measurement-based quantum computation. We identify three main categories of client: emission-based, measurement-based, and rotation-based, each with multiple variants depending on how the client interacts with the server. We evaluate each across different dimensions: we compare guarantees of existing corresponding security proofs, we derive equations for the rate at which each client can execute a protocol, we provide an overview of each architecture's error behaviour, and discuss hardware cost and design considerations. Client architectures implementing measurement-based remote state preparation and reflection-based teleportation emerge as strong default candidates, but as the right choice remains context-dependent, we provide a framework for navigating considerations to guide the selection of the most suitable architecture for a given setting.

quant-pharXiv:2607.05650•Jul 8, 2026•0 citations
Recent years have seen much excitement for application of quantum computing, triggered by substantial — and ongoing — advances in experimental realizations of quantum computing. It is widely believed that client-server is the setting for quantum computers that will prevail in the future, where privacy becomes crucial in the application. Moreover, a recent experiment by Barz et al. [1] successfully demonstrated a blind quantum computation scheme: a client-server quantum computation in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing valuable details of the computation. In this thesis, we discuss the Blind Oracular Quantum Computation (BOQC) scheme, a blind quantum computing scheme in which a third party (the oracle)with limited quantum power, assists the execution of a client’s oracular quantum computations by implementing oracle evaluations. In BOQC, a client with limited quantum power and without the capacity to construct the oracle, can delegate her oracular quantum computations to a powerful yet untrustworthy server, with the help of the oracle. We show that BOQC is provably blind within a composable definition such that the server cannot learn about the clients’ computation. We provide a realization of BOQC in a physical setting, particularly in a diamond nitrogen-vacancy (NV) center platform. In BOQC, the server has a One-Way Quantum Computer (1WQC) that is resource-demanding. To lower the resource-requirements, we develop the BOQCo protocol, a BOQC that employs lazy 1WQC to minimize the number of qubits needed. We also provide systematic numerical optimization to find resource states that are BOQC-compatible by admitting BOQC security criteria. Finally, we give explicit oracular quantum algorithms that are BOQC-compatible to be executed on the NV-center platform. The algorithms include 2-qubit Grover’s algorithm using three qubits, 3-qubit exact Grover’s algorithm using four qubits, 2-qubit Simon’s algorithm with a useless oracle using four qubits, and Deutsch’s algorithm using three physical qubits. We hope that these BOQC algorithms intrigue some experimentalists to try to implement them.[1] S. Barz et al. “Demonstration of Blind Quantum Computing”. In: Science 335.6066 (2012), pp. 303–308.
Here we put into practice the concept of blind client-server quantum computation, in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing any details of the computation. In particular, it is a three-node setting in which an oracular quantum computation can be executed blindly. In this Blind Oracular Quantum Computation (BOQC), the oracle (Oscar) is another node, with limited power, who acts in cooperation with the client (Alice) to supply quantum information to the server so that the oracle part of the quantum computation can also be executed blindly. We develop tests of this protocol using two- and three-qubit versions of the exact Grover algorithm (i.e., with database sizes $4\ensuremath{\le}N\ensuremath{\le}8$), obtaining optimal implementations of these algorithms within a gate array scheme and the blinded cluster-state scheme. We discuss the feasibility of executing these protocols in state-of-the-art three-node experiments using nitrogen-vacancy diamond electronic and nuclear qubits.
Abstract In the standard oracle model, an oracle efficiently evaluates an unknown classical function independent of the quantum algorithm itself. Quantum algorithms have a complex interrelationship to their oracles; for example the possibility of quantum speedup is affected by the manner by which oracles are implemented. Therefore, it is physically meaningful to separate oracles from their quantum algorithms, and we introduce one such separation here. We define the blind oracular quantum computation (BOQC) scheme, in which the oracle is a distinct node in a quantum network. Our work augments the client–server setting of quantum computing, in which a powerful quantum computer server is available on the network for discreet use by clients on the network with low quantum power. In BOQC, an oracle is another client that cooperates with the main client so that an oracular quantum algorithm is run on the server. The cooperation between the main client and the oracle takes place (almost) without communication. We prove BOQC to be blind: the server cannot learn anything about the clients’ computation. This proof is performed within the composable security definitions provided by the formalism of abstract cryptography. We enhance the BOQC scheme to be runnable with minimal physical qubits when run on a solid-state quantum network; we prove that this scheme, which we refer to as BOQCo (BOQC-optimized), possesses the same security as BOQC.
Here we extend the concept of blind client-server quantum computation, in which a client with limited quantum power controls the execution of a quantum computation on a powerful server, without revealing any details of the computation. Our extension is to introduce a three-node setting in which an oracular quantum computation can be executed blindly. In this Blind Oracular Quantum Computation (BOQC), the oracle (Oscar) is another node, with limited power, who acts in cooperation with the client (Alice) to supply quantum information to the server so that the oracle part of the quantum computation can also be executed blindly. We develop tests of this protocol using two- and three-qubit versions of the exact Grover algorithm (i.e., with database sizes 4≤N≤84\leq N\leq 84≤N≤8), obtaining optimal implementations of these algorithms within a gate array scheme and the blinded cluster-state scheme. We discuss the feasibility of executing these protocols in state-of-the-art three-node experiments using NV-diamond electronic and nuclear qubits.
Current cloud-based quantum processors offer access to advanced hardware hosted on a remote server, but do not guarantee data or algorithm privacy. Blind quantum computation provides information-theoretic privacy by enabling a client to execute an algorithm without disclosing information about either the task or the final result. Here, we execute a measurement-based blind quantum computation protocol on a superconducting processor comprising two flip-chip-bonded modules, one acting as a server and the other as a client. The server generates a two-dimensional cluster state and forwards it to the client. Using this resource, the client implements a universal gate set with only adaptive single-qubit rotations and measurements. To illustrate this approach, we execute a three-qubit instance of the Deutsch-Jozsa algorithm. We analyze the server's quantum state after each rotation of a measurement-based single-qubit gate to verify that negligible information about the computation is revealed to the server, consistent with the one-way flow of information that guarantees blindness. This proof-of-principle demonstration establishes key elements of blind quantum computation in superconducting-circuit architectures, indicating that intermediate-scale implementations of blind protocols may become feasible with realistic near-term improvements in gate fidelities.
Quantum computers, besides offering substantial computational speedups, are also expected to preserve the privacy of a computation. We present an experimental demonstration of blind quantum computing in which the input, computation, and output all remain unknown to the computer. We exploit the conceptual framework of measurement-based quantum computation that enables a client to delegate a computation to a quantum server. Various blind delegated computations, including one- and two-qubit gates and the Deutsch and Grover quantum algorithms, are demonstrated. The client only needs to be able to prepare and transmit individual photonic qubits. Our demonstration is crucial for unconditionally secure quantum cloud computing and might become a key ingredient for real-life applications, especially when considering the challenges of making powerful quantum computers widely available.
Blind quantum computing (BQC) allows a client to delegate quantum computations to a remote server without revealing the input, computation, or output. In addition to being blind, the client can sometimes also verify that the server has performed their instructions correctly, a property known as verifiability. A key part of realizing such verifiable BQC (VBQC) is choosing the design of the client device: many architectures have been proposed, each with different hardware requirements, security properties, and performance characteristics, making it difficult to identify which is most suitable for a given implementation. In this work, we present a comparative analysis of client architectures for VBQC with a matter-qubit server. We restrict our analysis to single-server, single-client protocols with information-theoretic security based on measurement-based quantum computation. We identify three main categories of client: emission-based, measurement-based, and rotation-based, each with multiple variants depending on how the client interacts with the server. We evaluate each across different dimensions: we compare guarantees of existing corresponding security proofs, we derive equations for the rate at which each client can execute a protocol, we provide an overview of each architecture's error behaviour, and discuss hardware cost and design considerations. Client architectures implementing measurement-based remote state preparation and reflection-based teleportation emerge as strong default candidates, but as the right choice remains context-dependent, we provide a framework for navigating considerations to guide the selection of the most suitable architecture for a given setting.