As quantum computing transitions from theoretical blueprints to physical hardware, a practical bottleneck emerges: quantum computers are massive, expensive, and delicate machines. Most users will not own a quantum computer; instead, they will access quantum hardware remotely via the cloud.
This delegation creates a fundamental privacy conflict. If a client wants a cloud server to run a quantum algorithm on sensitive data—such as a proprietary machine learning dataset or a financial transaction—how can they prevent the untrusted server from reading the input data, spying on the intermediate states, or stealing the final output?
The solution lies in Quantum Fully Homomorphic Encryption (QFHE). QFHE allows an untrusted quantum server to perform arbitrary quantum circuits directly on encrypted quantum data. The server manipulates the data to execute the algorithm but learns absolutely nothing about the underlying information.
The Core Intuition: Computing Through a Mask
To understand why QFHE is possible, we must look at how quantum data is encrypted. A standard way to hide a quantum state $|\psi\rangle$ is the Quantum One-Time Pad (QOTP). The client encrypts the state by applying a random combination of Pauli operators—bit flips ($X$) and phase flips ($Z$)—based on a secret classical key. To the server, this encrypted state looks like complete, uninformative noise (a maximally mixed state).
The magic of homomorphic encryption is that we can compute on this noise. When the server applies a quantum gate to the encrypted state, the gate interacts with the underlying data and the encryption mask.
For a large class of operations known as Clifford gates (such as the CNOT, Hadamard, and Phase gates), this interaction is clean and predictable. The encryption mask simply transforms into a different set of Pauli operators.
Client's State ─── [ QOTP Encryption (X, Z) ] ─── [ Server's Clifford Gate ] ─── Encrypted Output
│
Transforms the Pauli Keys
Because the client knows the original key, they can track exactly how the encryption mask evolves after each gate. The server applies the gates blindly, and the client updates their classical keys to decrypt the final result.
Overcoming the Non-Clifford Bottleneck
While Clifford gates are easy to handle, they are not enough to achieve universal quantum computation. Universal quantum circuits require non-Clifford gates, most notably the T-gate.
When a server applies a T-gate to a QOTP-encrypted state, the encryption keys do not just transform into new keys; they become entangled with the data in a way that corrupts the computation unless an operational correction is applied. Resolving this "T-gate bottleneck" is a primary focus of secure quantum delegation architectures.
One approach to solving this is to introduce specialized server architectures. For instance, Changqing Gong et al. proposed a trusted server architecture designed to manage keys and handle intermediate decryptions specifically for complex gate operations. By isolating the T-gate corrections within a secure management layer, the authors demonstrated that complex, data-heavy quantum algorithms—such as a quantum k-means clustering algorithm—can be executed securely in the cloud without exposing client data (Quantum k-means algorithm based on trusted server in quantum cloud computing).
From Theory to Practical Cloud Deployments
The feasibility of this approach has transitioned from purely mathematical proofs to physical implementations on real quantum hardware.
The first experimental proof-of-concept on a commercial cloud platform was achieved by He-Liang Huang et al.. The authors adapted a quantum homomorphic encryption scheme to run on IBM’s cloud quantum computing platform, successfully solving systems of linear equations (Homomorphic encryption experiments on IBM’s cloud quantum computing platform). Their experiment proved that despite the noise and imperfections of current quantum hardware, homomorphic encryption can successfully protect user inputs and results throughout an entire algorithmic run.
As datasets grow, sending massive amounts of encrypted quantum data to the cloud becomes a bandwidth bottleneck. To address this, Changqing Gong et al. developed a method for quantum ciphertext dimension reduction (Quantum Ciphertext Dimension Reduction Scheme for Homomorphic Encrypted Data). By leveraging quantum principal component extraction (QPCE) directly on homomorphic encrypted data, the cloud server can compress the encrypted dataset on its own, saving quantum storage and communication overhead without ever decrypting the files.
Compiling Blindness and Verifiability
QFHE does more than just protect data privacy; it serves as a foundational building block for broader cryptographic properties, such as blindness (hiding the algorithm itself) and verifiability (proving the server didn't cheat).
In delegated computation, a client often needs to verify that the quantum server actually ran the requested circuit correctly, rather than just returning random numbers. Kai-Min Chung et al. demonstrated that QFHE can be used as a powerful primitive to build a generic compiler (Constant-Round Blind Classical Verification of Quantum Sampling). This compiler takes any standard classical verification protocol and automatically transforms it into a "blind" protocol. Because the underlying computation is wrapped in a homomorphic layer, the server can generate a proof of correctness for sampling problems without ever learning what it is sampling or verifying.
Standard Verification Protocol ───► [ QFHE Compiler ] ───► Blind & Verifiable Protocol
(Server proves correctness
without seeing the data)
Novel Applications: Secure Quantum Money
The utility of processing encrypted quantum states extends beyond traditional data analytics into novel quantum protocols, such as unforgeable currency.
Quantum money relies on the no-cloning theorem to create tokens that cannot be counterfeited. However, validating this money typically requires complex quantum operations that an ordinary user or a local bank branch cannot perform. To bridge this gap, Siyuan Jin et al. designed a cloud-based semi-quantum money framework (Cloud-based Semi-Quantum Money).
By utilizing QFHE, a classical user can upload an encrypted version of their quantum token to an untrusted cloud server. The server performs the heavy quantum verification circuits homomorphically and returns an encrypted validation signal. Because of the QFHE layer, the untrusted cloud provider facilitates the transaction without ever gaining access to the secret serial numbers or the underlying quantum states of the currency, preserving both security and user privacy.
Key Foundational Work
Homomorphic Encryption Experiments on IBM's Cloud Quantum Computing Platform (2016) — contributed 6 concept elements to this direction.
Quantum k-means algorithm based on trusted server in quantum cloud computing (2021) — contributed 3 concept elements to this direction.
Quantum Ciphertext Dimension Reduction Scheme for Homomorphic Encrypted Data (2021) — contributed 1 concept elements to this direction.