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 Quantum Computation with a Small Quantum Server — E8 Intelligence Research

Andrew Stewart Caldin

Published Nov 7, 2026• 0 citations
Publisher

Abstract

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. Source: http://arxiv.org/abs/2609.20729v1 (arXiv:2609.20729v1) Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

DOI
10.5281/zenodo.24029492

Related papers

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

Designing Fault-Tolerant Blind Quantum Computation

Gefen Baranes, Wang, Iria W., Francisco Machado +6 more

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.

arXiv:2505.21621•May 27, 2025•9 citations

Resource-Efficient Secure Delegation via Pauli-Based Computation

Daniel Lovsted

The scarcity of quantum resources is a significant theme in quantum cryptography and computation. Within quantum cryptography, secure delegated quantum computation (SDQC) allows low-resource users to access quantum computation with privacy. From the study of models of quantum computation, Pauli-based computation (PBC) has emerged as a resource-efficient alternative to conventional models. In this thesis, we merge these two strands of work, presenting the first protocol for SDQC in the PBC model. Our protocol allows a client with minimal quantum resources to execute a PBC on a secret classical input of their choice by interacting with a quantum server. We prove that the protocol gives the client perfect, information-theoretic security. Our protocol inherits the resource efficiencies of PBC, significantly reducing the size of the quantum register required by the server, implying that SDQC could be available sooner than anticipated in a world of scarce quantum resources.

•Aug 19, 2026•0 citations

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

A simplified verifiable blind quantum computing protocol with quantum input verification

Junyu Quan, Qin Li, Chengdong Liu +2 more

Blind quantum computing (BQC) enables a client with limited quantum capability to delegate her quantum computation to a remote quantum server and still keeps the client's input, output, and the algorithm private. One important property of BQC is verifiability, which means the client can verify the correctness of the computation or unknown quantum inputs. Recently, Morimae proposed a verifiable blind quantum computing protocol where the client can verify both the correctness of computing and the quantum input. However, the client needs much quantum memory and takes a lot of qubits to get the true result. We reduce the size of quantum memory and the number of qubits used in Morimae's protocol. Besides, we extend the resource state in Morimae's protocol from graph state to hypergraph state. For certain hypergraph states as resources states, such as Union Jack State, the client only needs Pauli measurements in the computation stage but he needs non-Clifford basis measurements if graph states are considered as resources states.

Quantum Engineering•Jan 3, 2021•19 citations
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. Source: http://arxiv.org/abs/2609.20729v1 (arXiv:2609.20729v1) Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com
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.
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.
The scarcity of quantum resources is a significant theme in quantum cryptography and computation. Within quantum cryptography, secure delegated quantum computation (SDQC) allows low-resource users to access quantum computation with privacy. From the study of models of quantum computation, Pauli-based computation (PBC) has emerged as a resource-efficient alternative to conventional models. In this thesis, we merge these two strands of work, presenting the first protocol for SDQC in the PBC model. Our protocol allows a client with minimal quantum resources to execute a PBC on a secret classical input of their choice by interacting with a quantum server. We prove that the protocol gives the client perfect, information-theoretic security. Our protocol inherits the resource efficiencies of PBC, significantly reducing the size of the quantum register required by the server, implying that SDQC could be available sooner than anticipated in a world of scarce quantum resources.
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.
Blind quantum computing (BQC) enables a client with limited quantum capability to delegate her quantum computation to a remote quantum server and still keeps the client's input, output, and the algorithm private. One important property of BQC is verifiability, which means the client can verify the correctness of the computation or unknown quantum inputs. Recently, Morimae proposed a verifiable blind quantum computing protocol where the client can verify both the correctness of computing and the quantum input. However, the client needs much quantum memory and takes a lot of qubits to get the true result. We reduce the size of quantum memory and the number of qubits used in Morimae's protocol. Besides, we extend the resource state in Morimae's protocol from graph state to hypergraph state. For certain hypergraph states as resources states, such as Union Jack State, the client only needs Pauli measurements in the computation stage but he needs non-Clifford basis measurements if graph states are considered as resources states.