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:2505.21621

Designing Fault-Tolerant Blind Quantum Computation

Gefen Baranes, Wang, Iria W., Francisco Machado, Aziza Suleymanzade, Pieter-Jan Stas, Yan-Cheng Wei, Susanne F. Yelin, Johannes Borregaard, Mikhail D. Lukin

Published May 27, 2025• 9 citations
arXivHTMLPDF

Abstract

Blind quantum computing (BQC) is a computational paradigm that allows a client with limited quantum capabilities to delegate quantum computations to a more powerful server while keeping both the algorithm and data hidden. However, in practice, existing BQC protocols face significant challenges when scaling to large-scale computations due to photon losses, low efficiencies, and high overheads associated with fault-tolerant operations, requiring the client to compile both logical operations and error correction primitives. We use a recently demonstrated hybrid light-matter approach [PRL 132, 150604 (2024); Science 388, 509-513 (2025)] to develop an architecture for scalable fault-tolerant blind quantum computation. By combining high-fidelity local gates on the server's matter qubits with delegated blind rotations using photons, we construct loss-tolerant delegated gates that enable efficient algorithm compilation strategies and a scalable approach for fault-tolerant blind logical algorithms. Our approach improves the error-correction threshold and increases the speed and depth of blind logical circuits. Finally, we outline how this architecture can be implemented on state-of-the-art quantum hardware, including neutral atom arrays and solid-state spin defects. These new capabilities open up new opportunities for deep circuit blind quantum computing.

DOI
10.48550/arxiv.2505.21621

Related papers

Fault-Tolerant Operations for Universal Blind Quantum Computation

Chia-Hung Chien, Rodney Van Meter, Sy‐Yen Kuo

Blind quantum computation is an appealing use of quantum information technology because it can conceal both the client's data and the algorithm itself from the server. However, problems need to be solved in the practical use of blind quantum computation and fault-tolerance is a major challenge. Broadbent et al. proposed running error correction over blind quantum computation, and Morimae and Fujii proposed using fault-tolerant entangled qubits as the resource for blind quantum computation. Both approaches impose severe demands on the teleportation channel, the former requiring unrealistic data rates and the latter near-perfect fidelity. To extend the application range of blind quantum computation, we suggest that Alice send input qubits encoded with error correction code instead of single input qubits. Two fault-tolerant protocols are presented and we showed the trade-off of the computational overhead using the ten-bit quantum carry-lookahead adder as an example. Though these two fault-tolerant protocols require the client to have more quantum computing ability than using approaches from prior work, they provide better fault-tolerance when the client and the server are connected by realistic quantum repeater networks.

arXiv:1306.3664•ACM Journal on Emerging Technologies in Computing Systems•Aug 3, 2015•32 citations

Blind Quantum Computation with a Small Quantum Server

Daniel Lovsted, Filipa C. R. Peres, Joshua Nevin +2 more

Blind quantum computation (BQC) allows low-resource clients to securely delegate computations to a quantum server, but server resource costs scale with the computation size, posing a bottleneck for implementations. By leveraging Pauli-based computation (PBC), we achieve BQC with a server whose size depends only on the non-Clifford gate count. Our protocol inherits fault tolerance and qubit virtualization from PBC and reveals that classical-client BQC is possible even in the absence of classical simulability. Finally, we present an entanglement-based dual protocol that performs a resource state computation with a dramatically reduced execution cost.

quant-pharXiv:2609.20729•Sep 18, 2026•1 citation

Practical blind quantum computation with parity quantum computing framework

Yuxun Wang, Qin Li, Shao‐Ming Fei +1 more

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.

Quantum Science and Technology•Mar 19, 2026•1 citation

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

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•15 citations

Blind quantum computation with completely classical client and a trusted center

Min Liang

Blind quantum computation (BQC) enables a client without enough quantum power to delegate his quantum computation to a quantum server, while keeping the input data, the algorithm and the result unknown to the server. In the studies of practical BQC protocol, an important problem is how to reduce the quantum requirement of the client. Multi-server BQC protocols have been proposed to solve this problem. We review the double-server and triple-server protocols [Li et al., Phys. Rev. A 89, 040302(R) (2014)], and propose a modified double-server BQC protocol with a trusted center. In our protocol, the servers are allowed to communicate mutually, and the client is completely classical. Furthermore, our double-server protocol can be modified into a single-server protocol by simply combining the two servers. Compared with the triple-server protocol, our double-server and single-server protocols are more simple and the client is not required to have the ability to access quantum channel. So our protocols are more practical when quantum computer is applied in the `cloud' model.

arXiv:1508.07778•Aug 31, 2015•1 citation
Blind quantum computing (BQC) is a computational paradigm that allows a client with limited quantum capabilities to delegate quantum computations to a more powerful server while keeping both the algorithm and data hidden. However, in practice, existing BQC protocols face significant challenges when scaling to large-scale computations due to photon losses, low efficiencies, and high overheads associated with fault-tolerant operations, requiring the client to compile both logical operations and error correction primitives. We use a recently demonstrated hybrid light-matter approach [PRL 132, 150604 (2024); Science 388, 509-513 (2025)] to develop an architecture for scalable fault-tolerant blind quantum computation. By combining high-fidelity local gates on the server's matter qubits with delegated blind rotations using photons, we construct loss-tolerant delegated gates that enable efficient algorithm compilation strategies and a scalable approach for fault-tolerant blind logical algorithms. Our approach improves the error-correction threshold and increases the speed and depth of blind logical circuits. Finally, we outline how this architecture can be implemented on state-of-the-art quantum hardware, including neutral atom arrays and solid-state spin defects. These new capabilities open up new opportunities for deep circuit blind quantum computing.
Blind quantum computation is an appealing use of quantum information technology because it can conceal both the client's data and the algorithm itself from the server. However, problems need to be solved in the practical use of blind quantum computation and fault-tolerance is a major challenge. Broadbent et al. proposed running error correction over blind quantum computation, and Morimae and Fujii proposed using fault-tolerant entangled qubits as the resource for blind quantum computation. Both approaches impose severe demands on the teleportation channel, the former requiring unrealistic data rates and the latter near-perfect fidelity. To extend the application range of blind quantum computation, we suggest that Alice send input qubits encoded with error correction code instead of single input qubits. Two fault-tolerant protocols are presented and we showed the trade-off of the computational overhead using the ten-bit quantum carry-lookahead adder as an example. Though these two fault-tolerant protocols require the client to have more quantum computing ability than using approaches from prior work, they provide better fault-tolerance when the client and the server are connected by realistic quantum repeater networks.
Blind quantum computation (BQC) allows low-resource clients to securely delegate computations to a quantum server, but server resource costs scale with the computation size, posing a bottleneck for implementations. By leveraging Pauli-based computation (PBC), we achieve BQC with a server whose size depends only on the non-Clifford gate count. Our protocol inherits fault tolerance and qubit virtualization from PBC and reveals that classical-client BQC is possible even in the absence of classical simulability. Finally, we present an entanglement-based dual protocol that performs a resource state computation with a dramatically reduced execution cost.
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.
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.
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 computation (BQC) enables a client without enough quantum power to delegate his quantum computation to a quantum server, while keeping the input data, the algorithm and the result unknown to the server. In the studies of practical BQC protocol, an important problem is how to reduce the quantum requirement of the client. Multi-server BQC protocols have been proposed to solve this problem. We review the double-server and triple-server protocols [Li et al., Phys. Rev. A 89, 040302(R) (2014)], and propose a modified double-server BQC protocol with a trusted center. In our protocol, the servers are allowed to communicate mutually, and the client is completely classical. Furthermore, our double-server protocol can be modified into a single-server protocol by simply combining the two servers. Compared with the triple-server protocol, our double-server and single-server protocols are more simple and the client is not required to have the ability to access quantum channel. So our protocols are more practical when quantum computer is applied in the `cloud' model.