⚛️ quantum physics

Quantum Homomorphic Encryption: Towards Practical and Private Computation on Untrusted Quantum Hardware

This paper proposes a universal, information-theoretically secure Quantum Homomorphic Encryption framework (QOTPH) based on the Quantum One-Time Pad that enables non-interactive, private computation on encrypted quantum states across Clifford+T and variational circuits, with its correctness and key secrecy experimentally validated on both simulated and real quantum hardware.

Original authors: Jon Hernández-Bueno, Oscar Lage, Marivi Higuero, Jasone Astorga

Published 2026-04-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jon Hernández-Bueno, Oscar Lage, Marivi Higuero, Jasone Astorga

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a incredibly valuable, secret recipe for a cake. You want to bake it, but you don't have a kitchen, so you hire a stranger (a "cloud" service) to do it for you.

The problem? You don't trust this stranger. If you give them the recipe, they might steal it. If you give them the ingredients, they might eat them. You need a way to let them bake the cake without ever seeing the recipe or the ingredients.

This is the problem of Homomorphic Encryption. In the classical world (regular computers), we have solutions for this, but they are slow and complex. In the Quantum world (super-fast computers that use the laws of physics), this has been a massive, unsolved puzzle.

This paper presents a solution called QOTPH (Quantum One-Time Pad Homomorphic Encryption). Here is how it works, explained through simple analogies.

1. The Magic Box (The Quantum One-Time Pad)

Think of your secret data (the recipe) as a precious gem inside a box.

The Encryption: You put the gem in a box and lock it with a random, unbreakable padlock. In quantum terms, this is called the Quantum One-Time Pad (QOTP).
The Result: To anyone looking at the box (the untrusted computer), it looks like a completely empty, random box. They have no idea what's inside. Even if they shake it, they can't tell.

2. The Problem: Baking Without Opening the Box

Usually, if you want the stranger to bake the cake, you have to open the box, give them the gem, and let them work. But that defeats the purpose of secrecy.

The Old Way: In the past, quantum computers couldn't do math on locked boxes. If you tried to mix ingredients (apply a "gate") to the locked box, the lock would break, or the result would be garbage.
The New Solution: This paper introduces a special set of instructions that allows the stranger to mix, stir, and bake inside the locked box without ever opening it.

3. The Secret Recipe for the Stranger (Key Updates)

How does the stranger bake the cake if they can't see the ingredients?

The Analogy: Imagine the stranger has a special "magic wand" for every type of cooking action (chopping, mixing, baking).
The Trick: When the stranger uses a wand on the locked box, the lock changes shape slightly. But the person who owns the box (you) has a secret notebook.
The Process:
1. You send the locked box to the stranger.
2. The stranger performs the cooking steps.
3. Every time they use a wand, they send you a tiny note saying, "I used the Chopping Wand."
4. You look at your secret notebook and update your own lock instructions. You don't tell them what you are doing, just how the lock changed.
5. By the time the cake is done, the box is still locked, but the lock has been updated to match the new cake inside.

4. The Two Ways to Get the Cake

The paper tests two ways to get the final result:

Method A (In-Circuit Decryption): The stranger finishes baking, then uses your updated instructions to unlock the box right there in their kitchen, takes a picture of the cake, and sends you the photo.
- Risk: The stranger sees the cake.
Method B (Local Decryption - The Winner): The stranger finishes baking and sends you the still-locked box (or a photo of the locked box). You take it home, use your secret notebook to unlock it, and then you see the cake.
- Benefit: The stranger never sees the final result. They only see a random, locked box.

5. What Did They Actually Do?

The authors didn't just write theory; they built it.

They wrote a computer program (using a tool called Qiskit) that automatically handles all these "magic wands" and "notebook updates."
They tested it on real quantum computers (IBM's machines) and on perfect simulators.
The Result: It worked! Even though real quantum computers are "noisy" (like a kitchen with a shaky table), the system was able to bake the cake correctly about 93% to 99% of the time.

Why Does This Matter?

Privacy: You can use powerful quantum computers owned by big companies (like Google or IBM) to solve your problems without them ever knowing what your data is.
Security: It uses "Information-Theoretic Security." This means it's not just "hard to crack" like a password; it is mathematically impossible for the stranger to learn anything about your data, even if they have infinite computing power.
The Future: This is a giant step toward a future where we can use the cloud for quantum computing without fear of spies or data theft.

The Catch

The only downside right now is that real quantum computers are still a bit "jittery" (noisy). As the computers get better and less noisy, this method will become even more perfect. But for now, it proves that secret quantum computing is possible.

In short: They figured out how to let a stranger cook your secret recipe in their kitchen, lock the result in a box, and send it back to you, so they never know what they cooked.

1. Problem Statement

As quantum computing matures, the need to perform computations on encrypted data within untrusted environments (e.g., quantum cloud services) has become urgent. While classical Fully Homomorphic Encryption (FHE) exists, a practical, universal, and fully homomorphic Quantum Homomorphic Encryption (QHE) scheme remains elusive.

The Core Challenge: Existing quantum encryption primitives, such as the Quantum One-Time Pad (QOTP), offer information-theoretic security but are generally incompatible with homomorphic computation. This is because arbitrary quantum gates do not commute with Pauli operators (the basis of QOTP), making it impossible to evaluate functions on encrypted data without decryption.
Current Limitations: Previous theoretical proposals often rely on heavy computational overhead, trusted third parties, or are limited to specific gate sets (Clifford only), failing to support universal quantum computation (Clifford + T) in a non-interactive manner on real hardware.

2. Methodology

The authors propose a universal framework called QOTPH (Quantum One-Time Pad Homomorphic), which extends the standard QOTP scheme to support homomorphic evaluation of arbitrary quantum circuits.

Core Mechanism: Key-Tracking and Gate Decomposition

The methodology relies on the algebraic properties of quantum gates under Pauli conjugation. Instead of decrypting data to compute, the system tracks the evolution of the encryption keys as gates are applied.

Encryption: Data is encrypted using QOTP, applying random $X^a Z^b$ operators to each qubit.
Homomorphic Evaluation: When a gate $G$ $G$ is applied to an encrypted state, the system does not simply apply $G$ $G$ . Instead, it:
1. Applies a modified gate $G'$ (or a decomposition of $G$ ) to the encrypted state.
2. Updates the secret keys $(a, b)$ deterministically based on the gate type and the current key state.
3. This ensures the semantic equivalence of the computation is preserved without the evaluator ever seeing the plaintext or the original keys.

Key Contributions to the Protocol

Universal Gate Set Support: The authors derived explicit key-update rules for the Clifford+T gate set, as well as controlled and parameterized operations (e.g., $R_x, R_y, R_z$ , CNOT, Toffoli, Fredkin).
Non-Interactive: The protocol requires no communication between the client (who holds the keys) and the untrusted quantum processor during execution. The processor simply executes the transformed circuit.
Two Execution Modes:
1. In-Circuit Decryption (Algorithm 1): The quantum processor applies the decryption layer before measurement.
2. Local Decryption (Algorithm 2): The processor returns encrypted measurement results. The client performs decryption locally using the updated keys. This mode offers higher privacy as the backend never sees the plaintext output.
Enhanced Security: The authors introduce random Swap gates before measurement to obscure qubit ordering, adding an extra layer of obfuscation against circuit analysis.

3. Key Contributions

First Experimental Validation on Real Hardware: This is the first work to experimentally validate a universal QOTP-based homomorphic scheme on real quantum processors (IBM Quantum devices), moving beyond theoretical simulations.
Systematic Key-Update Rules: The paper provides a comprehensive table of homomorphic implementations and key-update rules for a broad set of quantum gates, enabling the evaluation of arbitrary circuits expressible in the Clifford+T set.
Information-Theoretic Security: The scheme maintains the unconditional security of the QOTP. Without the secret keys, the encrypted state appears as a maximally mixed state to any adversary, revealing no information about the plaintext.
Modular Implementation: The protocol was implemented in Qiskit, creating a modular pipeline that handles state preparation, encryption, gate decomposition, key tracking, and decryption automatically.

4. Experimental Results

The authors tested the protocol on IBM Quantum devices (specifically the 156-qubit Heron r2 processor) and noiseless simulators.

Fidelity Metrics:
- Simulators: Achieved near-perfect fidelity ( $>0.999$ ), confirming the mathematical correctness of the protocol.
- Real Hardware: Achieved high fidelity despite hardware noise.
  - For 5–10 qubits: Fidelity ranged from 0.97 to 0.99.
  - For 20 qubits: Fidelity remained above 0.93.
  - For 40 qubits: Fidelity dropped to ~0.94 (limited by gate errors and decoherence).
Scalability: The results demonstrate that the protocol is robust for moderate circuit sizes (up to 20 qubits) on current superconducting hardware. The fidelity loss is attributed to intrinsic device noise (decoherence, gate errors) rather than the encryption protocol itself.
Security Validation: In the "Local Decryption" scenario, the quantum backend received only encrypted bitstrings that were statistically indistinguishable from random noise, confirming that the backend learns nothing about the computation or the data.

5. Significance and Future Implications

Bridging Theory and Practice: This work closes a critical gap between theoretical QHE concepts and practical realization, proving that privacy-preserving quantum computation is feasible on near-term, noisy intermediate-scale quantum (NISQ) devices.
Privacy-Preserving Cloud Quantum Computing: The protocol enables users to delegate complex quantum algorithms (e.g., Variational Quantum Eigensolvers) to untrusted cloud providers without revealing their data, algorithms, or results.
Limitations and Future Work:
- Hardware Noise: The primary bottleneck is current hardware error rates. Future work must focus on error mitigation and fault-tolerant hardware.
- Circuit Privacy: While data is hidden, the structure of the circuit (gate sequence) is visible to the provider. Future research aims to hide the circuit description itself (e.g., via Blind Quantum Computing techniques).
- Integrity: The current scheme ensures confidentiality but not integrity (the provider could theoretically deviate from the computation). Future extensions may integrate verifiability mechanisms.

In conclusion, the paper presents QOTPH as a scalable, symmetric, and information-theoretically secure primitive that enables non-interactive homomorphic evaluation on real quantum hardware, marking a significant step toward secure quantum cloud services.