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.
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.
In the noisy intermediate-scale quantum (NISQ) era, quantum computing resources are increasingly provided through cloud platforms, enabling users to perform quantum computations without owning expensive hardware. However, delegating computations to remote servers raises a key challenge: ensuring the privacy of the client’s input, algorithm, and output. To address this issue, we propose a circuit-model blind quantum computation (CMBQC) protocol that conceals the target quantum computation while decoupling the encryption and decryption keys. This key-decoupled structure avoids gate-by-gate propagation of decryption information on the client side. We establish blindness of the target operation within its Pauli equivalence class and prove the verifiability of the protocol, where verification is achieved by estimating expectation values of randomly chosen Pauli observables, thereby substantially reducing the verification overhead. We further demonstrate a single-qubit implementation of the CMBQC protocol on an International Business Machines Corporation (IBM) superconducting quantum system. The simple structure and low verification cost of the CMBQC protocol make it a promising framework for secure delegated quantum computation, with potential applications in quantum cloud computing.
We discuss how blind quantum computing generalizes to multilevel quantum systems (qudits), which offers advantages compared with the qubit approach. Here, a quantum computing task is delegated to an untrusted server while simultaneously preventing the server from retrieving information about the computation it performs, the input, and the output, enabling secure cloud-based quantum computing. In the standard approach with qubits, measurement-based quantum computing is used: single-qubit measurements on cluster or brickwork states implement the computation, while random rotations of the resource qubits hide the computation from the server. We generalize finite-sized approximately universal gate sets to prime-power-dimensional qudits and show that qudit versions of the cluster and brickwork states enable a similar server-blind execution of quantum algorithms. Furthermore, we compare the overheads of different resource state architectures and discuss which hiding strategies apply to alternative qudit resource states beyond graph states.
Abstract Blind quantum computation (BQC) allows clients with limited quantum capabilities to delegate computational tasks to remote quantum servers while keeping the privacy of their data. However, existing BQC protocols often fail to balance resource consumption and practical feasibility, which is particularly significant in the noisy intermediate-scale quantum era. In this paper, we propose a practical BQC model based on the parity quantum computing framework. It requires the server to perform operations only on adjacent qubits and eliminates the need for additional SWAP gates when two-qubit gates should be applied to non-adjacent qubits, greatly facilitating the physical implementation on real quantum devices. Furthermore, we prove that the proposed BQC model ensures the privacy of client’s information and satisfies the property of verifiability which enables clients to identify dishonest servers. Finally, a detailed example is given and simulated on the IBM’s quantum platform to demonstrate its feasibility.
The characteristics of BQC is that it enables a client with less quantum abilities to delegate her quantum computation to a server with strong quantum computablities while keeping the client's privacy. In this article, we study single client-server BQC based on measurement which is verifiable. In detail, the verifiability is that the client Alice can obtain the correct measurement results if the server Bob is honest, while Bob does not get nothing of Alice's secret information if he is malicious. We construct a latticed state, composed of six-qubit cluster states and eight-qubit entangled states, to realize Alice's quantum computing. In this proposed protocol, the cilent Alice prepares and sends initial single-qubit states to Bob, where the initial states include useful qubits and trap qubits. And then Bob performs controlled-Z gate to produce the entanglement and returns them to Alice. Alice will send trap qubits and useful qubits to Bob randomly and Bob returns all measurement results to her. Alice makes a comparison for trap qubits between true results and Bob's results to check the honesty of Bob. In a word, the trap qubtis have two purposes: 1) confusing Bob to keep the blindness; 2)verifying the honesty of Bob and correctness of Bob's quantum computing. There has an important feature that Alice does not need to encrypt the computing angles by rπ (r∈{0,1}), meanwhile the blindness and correctness can also be ensured. That is, Alice's computing results don't need to flipped since Bob is not impossible know anything about the quantum computation. Our work gives a better understanding for verifiable BQC based on measurement.
Blind quantum computing is a promising application of distributed quantum systems, in which a client can perform computations on a remote server without revealing any details of the applied circuit. Although the most promising realizations of quantum computers are based on various matter-qubit platforms, implementing blind quantum computing on matter qubits remains a challenge. Using silicon-vacancy (SiV) centers in nanophotonic diamond cavities with an efficient optical interface, we demonstrated a universal quantum gate set consisting of single- and two-qubit blind gates over a distributed two-node network. Using these ingredients, we performed a distributed algorithm with blind operations across our two-node network, proving a route to develop blind quantum computation with matter qubits in distributed, modular architectures.
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.