Teleportation-based quantum homomorphic encryption scheme with quasi-compactness and perfect security

TL;DR

This paper introduces a teleportation-based quantum homomorphic encryption scheme that achieves perfect security and quasi-compactness, optimized for circuits with low T/T†-gate complexity, advancing secure quantum computation.

Contribution

It presents two new non-interactive, perfectly secure QHE schemes, exttt{GT} and exttt{VGT}, with bounded quasi-compactness proportional to T/T†-gates, improving efficiency for low gate complexity circuits.

Findings

Schemes are exttt{F}-homomorphic and quasi-compact with complexity O(M).

exttt{VGT} is proven optimal with M-quasi-compactness.

Suitable for polynomial-size quantum circuits with low T/T†-gate count.

Abstract

This article defines encrypted gate, which is denoted by $EG[U]:|\alpha\rangle\rightarrow\left((a,b),Enc_{a,b}(U|\alpha\rangle)\right)$. We present a gate-teleportation-based two-party computation scheme for $EG[U]$, where one party gives arbitrary quantum state $|\alpha\rangle$ as input and obtains the encrypted $U$-computing result $Enc_{a,b}(U|\alpha\rangle)$, and the other party obtains the random bits $a,b$. Based on $EG[P^x](x\in\{0,1\})$, we propose a method to remove the $P$-error generated in the homomorphic evaluation of $T/T^\dagger$-gate. Using this method, we design two non-interactive and perfectly secure QHE schemes named \texttt{GT} and \texttt{VGT}. Both of them are $\mathcal{F}$-homomorphic and quasi-compact (the decryption complexity depends on the $T/T^\dagger$-gate complexity). Assume $\mathcal{F}$-homomorphism, non-interaction and perfect security are necessary property, the quasi-compactness is proved to be bounded by $O(M)$, where $M$ is the total number of $T/T^\dagger$-gates in the evaluated circuit. \texttt{VGT} is proved to be optimal and has $M$-quasi-compactness. According to our QHE schemes, the decryption would be inefficient if the evaluated circuit contains exponential number of $T/T^\dagger$-gates. Thus our schemes are suitable for homomorphic evaluation of any quantum circuit with low $T/T^\dagger$-gate complexity, such as any polynomial-size quantum circuit or any quantum circuit with polynomial number of $T/T^\dagger$-gates.

Equations

$$CNOT|c⟩|t⟩=|c⟩|t\oplus c⟩,\forall c,t\in \{0,1\}.$$

$$\frac{1}{2^{2n}}\sum _{a,b\in \{0,1{\}}^n}{X}^a{Z}^b\sigma (X^a{Z}^b{)}^{†}=\frac{I_{2^n}}{2^n},$$

$$|{\Phi }_{ab}⟩=(Z^b{X}^a\otimes I)|{\Phi }_{00}⟩,\forall a,b\in \{0,1\}.$$

$$\Phi (U)=\{|\Phi (U{)}_{ab}⟩,a,b\in \{0,1\}\},$$

$$|\alpha ⟩\otimes |{\Phi }_{00}⟩=\sum _{a,b\in \{0,1\}}|{\Phi }_{ab}⟩\otimes X^a{Z}^b|\alpha ⟩.$$

$$|\alpha ⟩\otimes |{\Phi }_{00}⟩=\sum _{a,b\in \{0,1\}}|\Phi (U{)}_{ab}⟩\otimes X^a{Z}^{b}U|\alpha ⟩,$$

$$|\alpha ⟩\otimes |{\Phi }_{00}⟩=\sum _{a,b\in \{0,1\}}|\Phi (P^x{)}_{ab}⟩\otimes X^a{Z}^b{P}^x|\alpha ⟩,\forall x.$$

$$P^{x}T{X}^x{Z}^z=X^x{Z}^{x\oplus z}T,\forall x,z\in \{0,1\}.$$

$$EG[P^x](T{X}^x{Z}^z|\alpha ⟩)$$

$$=$$

$$(X^x{Z}^z|\alpha ⟩{)}_1\otimes |\beta {⟩}_2\otimes |{\Phi }_{00}{⟩}_{s,c}$$

$$\stackrel{T_1}{\to }(T{X}^x{Z}^z|\alpha ⟩{)}_1\otimes |\beta {⟩}_2\otimes |{\Phi }_{00}{⟩}_{s,c}$$

$$\stackrel{SWA{P}_{1,s}}{\to }(T{X}^x{Z}^z|\alpha ⟩{)}_s\otimes |\beta {⟩}_2\otimes |{\Phi }_{00}{⟩}_{1,c}$$

$$\stackrel{{\Omega }_{1,2}}{\to }({\Omega }_{1,2}\otimes I_s\otimes I_c)((T{X}^x{Z}^z|\alpha ⟩{)}_s\otimes |{\Phi }_{00}{⟩}_{1,c}\otimes |\beta {⟩}_2)$$

$$=({\Omega }_{1,2}\otimes I_s\otimes I_c)\sum _{a,b\in \{0,1\}}|\Phi (P^x{)}_{ab}{⟩}_{s,c}\otimes X^a{Z}^b{P}^{x}T{X}^x{Z}^z|\alpha {⟩}_1\otimes |\beta {⟩}_2$$

$$=\sum _{a,b\in \{0,1\}}|\Phi (P^x{)}_{ab}{⟩}_{s,c}\otimes {\Omega }_{1,2}(X^{x\oplus a}{Z}^{x\oplus z\oplus b}T|\alpha {⟩}_1\otimes |\beta {⟩}_2)$$

$$\stackrel{U-\text{rotated Bell measurement}}{\to }$$

$$\Omega {\left((X^{x\oplus r_x}{Z}^{x\oplus z\oplus r_z}T|\alpha ⟩)\otimes |\beta ⟩\right)}_{1,2},\text{if the measurement outputs }{r}_z,r_x.$$

$$x_{j_i-1}(w_i)=\{\begin{array}{l}{g}_1(x_0,z_0),\text{if }i=1;\\ g_i(x_0,z_0,r_x(1),r_z(1),\dots ,r_x(i-1),r_z(i-1)),\\ \text{ if }i=2,\dots ,M.\end{array}$$

$$(x_{final},z_{final})=f(x_0,z_0,r_x(1),r_z(1),\dots ,r_x(M),r_z(M)).$$

$$b=\{\begin{array}{l}{g}_1(x_0,z_0),\text{if }i=1;\\ g_i(x_0,z_0,r_x(1),r_z(1),\dots ,r_x(i-1),r_z(i-1)),\\ \text{ if }i=2,\dots ,M.\end{array}$$

$$\Delta \left(\text{GT.Dec}\left(sk,\{\mathrm{qubit}{c}_i{\}}_{i=1}^M,\text{GT.Eval}\left(\mathcal{C},\{\mathrm{qubit}{s}_i{\}}_{i=1}^M,X^{x_0}{Z}^{z_0}\sigma Z^{z_0}{X}^{x_0}\right)\right),{\Phi }_{\mathcal{C}}(\sigma )\right)$$

$$\le negl(n),$$

$$X^{x_{final}}{Z}^{z_{final}}{\Phi }_{\mathcal{C}}(\sigma )Z^{z_{final}}{X}^{x_{final}},$$

$$\Delta \left(\text{GT.Dec}\left(sk,\{\mathrm{qubit}{c}_i{\}}_{i=1}^M,\text{GT.Eval}\left(\mathcal{C},\{\mathrm{qubit}{s}_i{\}}_{i=1}^M,X^{x_0}{Z}^{z_0}\sigma Z^{z_0}{X}^{x_0}\right)\right),{\Phi }_{\mathcal{C}}(\sigma )\right)$$

$$\equiv 0.$$

$$\{\begin{array}{l}{g}_i:\{0,1{\}}^{2n+2(i-1)}\to \{0,1\},i=1,\dots ,M;\\ f:\{0,1{\}}^{2n+2M}\to \{0,1{\}}^{2n}.\end{array}$$

$$x_{j_i-1}(w_i)=g_i(x_{j_{i-1}},z_{j_{i-1}}),i=1,\dots ,M.$$

$$(x_{j_i},z_{j_i})=f_i(x_{j_{i-1}},z_{j_{i-1}},r_x(i),r_z(i)),i=1,\dots ,M.$$

$$(x_{final},z_{final})=f_{M+1}(x_{j_M},z_{j_M}).$$

$$\text{VGT.Dec}(sk,\{g_i{\}}_{i=1}^M,\{f_i{\}}_{i=1}^{M+1},\{\mathrm{qubit}{s}_i,\mathrm{qubit}{c}_i{\}}_{i=1}^M,{\rho }^{\prime }).$$

$$\{\begin{array}{l}{g}_i:\{0,1{\}}^{2n}\to \{0,1\},i=1,\dots ,M,\\ f_i:\{0,1{\}}^{2n+2}\to \{0,1{\}}^{2n},i=1,\dots ,M,\\ f_{M+1}:\{0,1{\}}^{2n}\to \{0,1{\}}^{2n}.\end{array}$$

$$\Delta \left({\text{QHE.Dec}}_{sk}\left({\text{QHE.Eval}}^{C_{\kappa }}\left({\rho }_{evk},{\text{QHE.Enc}}_{sk}(\rho )\right)\right),{\Phi }_{C_{\kappa }}(\rho )\right)\le negl(\kappa ),$$

$$\parallel \text{QHE.Enc}({\rho }^{\mathrm{AE}})-{\Omega }^{{\mathrm{A}}^{\prime }}\otimes {\rho }^{\mathrm{E}}\parallel =0,$$

$$X^a{Z}^b$$

Full text

This article defines encrypted gate, which is denoted by $EG[U]:|\alpha\rangle\rightarrow\left((a,b),Enc_{a,b}(U|\alpha\rangle)\right)$. We present a gate-teleportation-based two-party computation scheme for $EG[U]$, where one party gives arbitrary quantum state $|\alpha\rangle$ as input and obtains the encrypted $U$-computing result $Enc_{a,b}(U|\alpha\rangle)$, and the other party obtains the random bits $a,b$. Based on $EG[P^{x}](x\in\{0,1\})$, we propose a method to remove the $P$-error generated in the homomorphic evaluation of $T/T^{\dagger}$-gate. Using this method, we design two non-interactive and perfectly secure QHE schemes named GT and VGT. Both of them are $\mathcal{F}$-homomorphic and quasi-compact (the decryption complexity depends on the $T/T^{\dagger}$-gate complexity).

Assume $\mathcal{F}$-homomorphism, non-interaction and perfect security are necessary property, the quasi-compactness is proved to be bounded by $O(M)$, where $M$ is the total number of $T/T^{\dagger}$-gates in the evaluated circuit. VGT is proved to be optimal and has $M$-quasi-compactness. According to our QHE schemes, the decryption would be inefficient if the evaluated circuit contains exponential number of $T/T^{\dagger}$-gates. Thus our schemes are suitable for homomorphic evaluation of any quantum circuit with low $T/T^{\dagger}$-gate complexity, such as any polynomial-size quantum circuit or any quantum circuit with polynomial number of $T/T^{\dagger}$-gates.

1 Introduction

Modern cryptography can ensure the security of communication. However, in the era of cloud computing, the computation is also required to be protected using cryptographic technology. As a key technology to guarantee the security of classical computation, fully homomorphic encryption (FHE) has been studied extensively since Gentry’s breakthrough result [1]. With the development of quantum computer, quantum computation would be practical in the near future, and provide quantum computing service for clients through the cloud. In order to ensure the security of cloud quantum computing, the researchers propose mainly two classes of quantum schemes: (1) blind quantum computation (BQC), and (2) quantum homomorphic encryption (QHE). Both of them are two-party delegated quantum computing technology.

BQC enables a client with weak quantum ability to delegate a quantum task to remote server with strong quantum ability, where the client’s input and final result are kept secret and the quantum program is only known by the client. QHE allows remote server to perform some quantum program $QC$ on encrypted quantum data $Enc(\rho)$ provided by a client, and the client can decrypt server’s output and obtain the result $QC(\rho)$. By comparing the functionality of BQC and QHE, the fundamental difference is that: BQC finishes a quantum program decided only by Client and Server cannot obtain Client’s quantum program; however, in QHE, the quantum program is decided by Server and it is unnecessary for Client to know the quantum program (actually it may be negotiated by both parties in advance). So BQC is more powerful than QHE and it is harder to design BQC scheme. When interaction is allowed, the design of BQC protocol has been tackled very well, and lots of results have been proposed in these literatures ([2, 3, 4, 5, 6, 7, 8]). Whether or not a non-interactive scheme exists for BQC? No result has been given at present.

In modern cryptography, FHE is usually achievable with non-interactive scheme. Similarly, quantum fully homomorphic encryption (QFHE) is also expected to be a non-interactive quantum algorithm. Actually, interaction can decrease the difficulty of the construction of QFHE scheme. For example, the scheme in Ref.[9] uses a few interactions, and its total number is the same as that of $T$-gates. Because the interactions necessarily decrease the efficiency of the protocol, this article focuses on interactive QHE scheme.

The early exploration of QHE begins in 2012. Rohde et al.[10] propose a simple symmetric-key QHE scheme, which allows quantum random walk on encrypted quantum data. Their scheme is not $\mathcal{F}$-homomorphic, that means it does not allow homomorphic evaluation of arbitrary quantum circuits. Later, Ref.[11] defines QFHE and constructs a weak scheme, which allows local quantum computation on encrypted data without access any plain data. This scheme does not accord with the usual concept of FHE, and its applicable situation is very limited. Ref.[12] proposes a QHE scheme for a large class of unitaries, but it cannot provide the security of cryptographic sense: it can hide only $n/\log n$ bits ($n$ is the size of the message), so the ratio of the hidden amount to the total amount approaches to 0 ($1/\log n\rightarrow 0$) when $n$ approaches to infinity.

Yu et al.[13] prove a no-go result: if non-interaction is required, any QFHE scheme with perfect security must use exponential size of storage; so it is impossible to construct an efficient QFHE scheme with perfect security. Later, the researchers study QHE schemes with certain loosen condition. For example, the interactivity is allowed in the schemes [9, 14], the expected security level is computational security [15, 16], the client accommodates the server with enough copies of encrypted ancillary states [17, 18]. The scheme in Ref.[9] is perfectly secure, however, it needs a few interactions, whose number is the same as the number of $T$-gates in universal quantum circuit. Though the schemes in Ref.[15] are non-interactive, they are constructed by the combination of quantum one-time pad (QOTP) and classical (fully) homomorphic encryption; so their efficiency and security would be bounded by classical homomorphic encryption scheme. The scheme proposed by Dulek et al.[16] is also non-interactive. In their scheme, it is necessary to use a ancillary gadget, in which the classical FHE scheme is used; so the security of the whole scheme would also be limited to the computational security of classical FHE scheme. Refs.[17, 18] associate homomorphic encryption with transversal computation, and propose non-interactive QFHE schemes based on quantum codes. In their schemes, Client must provide Server with sufficient copies of certain encrypted ancillary state; Too many copies of the ancillary states would leak some information about the secret key, so this kind of construction cannot achieve perfect security.

Besides the no-go result of Yu et al.[13], Newman and Shi [19] and Lai and Chung [20] independently prove an enhanced no-go result: it is impossible to construct non-interactive and information theoretically secure (ITS) QFHE scheme. According to their results, a QFHE scheme can achieve computational security at best if non-interaction is required. Then it is very natural to ask that: whether QHE scheme can provide quantum advantage than its classical counterpart? Lai and Chung [20] construct a non-interactive ITS QHE scheme, which has compactness. However, it is not $\mathcal{F}$-homomorphic but only partially homomorphic111A QHE scheme which is compact and not $\mathcal{F}$-homomorphic is called quantum somewhat homomorphic encryption scheme. This kind of QHE scheme is not studied in this article. In fact, it is also worth to study somewhat QHE scheme which is homomorphic for a sufficiently large class of quantum circuits.. Concretely, it only allows the homomorphic evaluation of a class of quantum circuits called instantaneous quantum polynomial-time (IQP) circuits

We consider non-interactive and perfectly secure QHE scheme, which is $\mathcal{F}$-homomorphic but not compact. Here QHE is not compact if its decryption procedure has dependence on the evaluated circuit. It is still worth to study QHE without compactness if decryption procedure has complexity that scales sublinearly in the size of evaluated circuit. This kind of property is called quasi-compactness [15]. This article will focus on QHE schemes with both $\mathcal{F}$-homomorphism and quasi-compactness.

1.1 Our Contributions

Generally, a QFHE scheme should be compact and can evaluate any quantum circuits homomorphically. Broadbent and Jeffery [15] define quasi-compactness for QHE following the quasi-compactness of FHE in Ref.[1]. They design a QHE scheme named EPR with quasi-compactness, which is also non-interactive and computationally secure. Then, if quasi-compactness is expected, whether there exists non-interactive and perfectly secure QHE scheme? This article will give a positive answer. Concretely, our contributions are listed as follows.

We define a new fundamental module named encrypted gate $EG[U]:|\alpha\rangle\rightarrow\left((a,b),Enc_{a,b}(U|\alpha\rangle)\right)$, where $a,b\in\{0,1\}$ are random bits, and $Enc_{a,b}$ represents quantum encryption transformation with the keys $a,b$. Based on gate teleportation, $EG[U]$ can be implemented by a two-party computation scheme, where one party obtains the classical part $a,b$ and the other party obtains the encrypted $U$-computing result (e.g.$Enc_{a,b}(U|\alpha\rangle)$). 2. 2.

In order to construct a QHE scheme, the main difficulty is that the homomorphic evaluation of $T/T^{\dagger}$-gate would cause a $P$-error ($P^{\dagger}$ in the formula $TX^{x}Z^{z}|\phi\rangle=(P^{\dagger})^{x}X^{x}Z^{x\oplus z}T|\phi\rangle$) which is hard to remove. Ref.[9] removes $P$-error using one round of interaction, and Ref.[16] removes $P$-error using an ancillary gadget with computational security. This article proposes a new method to remove $P$-error based on encrypted gate $EG[P^{x}]$: once a $T/T^{\dagger}$-gate is executed, Server together with Client should finish an encrypted gate $EG[P^{x}]$, where Client only performs quantum measurement; Based on principle of deferred measurement, all the measurements performed by Client can be deferred until Server finishes the homomorphic evaluation of the circuit, thus the interactions are avoided in the evaluation procedure. 3. 3.

By making use of our method to remove $P$-error, a QHE scheme GT and a variation VGT are constructed. Both the two QHE schemes have the four properties: non-interactive, perfect security, $\mathcal{F}$-homomorphism (or homomorphic evaluation of any quantum circuits), and quasi-compactness. The complexity of decryption depends on the total number of $T/T^{\dagger}$-gates in the evaluated circuit. 4. 4.

It is proved that, for any non-interactive and perfectly secure QHE scheme with $\mathcal{F}$-homomorphism, the optimal compactness is bounded by $M$-quasi-compactness. The first scheme GT can achieve $M\log M$-quasi-compactness, and the slightly modified version VGT can achieve the optimal bound.

It is worth to stress that: though our schemes are quasi-compact, it is still very efficient in homomorphic evaluation of any quantum circuits with low $T/T^{\dagger}$-gate complexity. If there are too many $T/T^{\dagger}$-gates in the evaluated circuit, then the decryption procedure would be inefficient. Here $M\log M$ or $M$-quasi-compactness can asymptotically describe how fast the decryption complexity increases along with $T/T^{\dagger}$-gates complexity. We hope the value of quasi-compactness is as small as possible. Then the QHE scheme can implement larger circuits if Client’s computational capability is fixed.

1.2 Related works

The QHE scheme EPR proposed by Broadbent and Jeffery [15] makes use of Bell state and quantum measurement. That scheme is constructed by the combination of QOTP and classical FHE, then it is computational secure. Moreover, it is proved to be $M^{2}$-quasi-compact, where $M$ is the number of $T$-gates in an evaluated circuit. In this article, our schemes also make use of Bell state and quantum measurement. However, our scheme VGT has perfect security and $M$-quasi-compactness, so it is better than EPR.

Yu et al.[13] prove a no-go result: if interaction is not allowed, there does not exist QFHE scheme with perfect security. An enhanced no-go result has been proved independently by Newman and Shi [19] and Lai and Chung [20]: if interaction is not allowed, there does not exist ITS QFHE scheme. This article focuses on the non-interactive and perfectly secure QHE schemes. Our schemes are quasi-compact, so they are not QFHE schemes, and then our result does not contradict with those no-go results. Though our schemes are not QFHE schemes, they can implement any unitary quantum circuit homomorphically (maybe inefficiently).

Alagic et al.[21] study computationally secure QFHE scheme, and define an additional property named verification. This article does not consider QHE with verification.

1.3 Organization

Section 2 introduces some preliminary knowledge about quantum computation, including gate teleportation. In Section 3, encrypted gate is defined and a method to remove $P$-error is proposed, then the homomorphic scheme for $T/T^{\dagger}$-gate is constructed. Section 4 contains the detailed QHE schemes and analysis.

2 Preliminaries

2.1 Quantum computation

For a detailed introduction about quantum computation, we refer the reader to Nielsen and Chuang [22]. Here we give a brief overview of some elementary quantum logic gates and notations.

Pauli $X$ and $Z$ gates are described as unitary operators X=\left(\begin{array}[]{cc}0&1\\ 1&0\\ \end{array}\right), and Z=\left(\begin{array}[]{cc}1&0\\ 0&-1\\ \end{array}\right). Hadamard gate is $H=\frac{1}{\sqrt{2}}(X+Z)$, and the phase gate is $P=\sqrt{Z}$. Controlled-NOT gate is CNOT=\left(\begin{array}[]{cccc}1&0&0&0\\ 0&1&0&0\\ 0&0&0&1\\ 0&0&1&0\\ \end{array}\right), and implements the following quantum transformation

[TABLE]

$T$-gate is T=\left(\begin{array}[]{cc}1&0\\ 0&e^{i\frac{\pi}{4}}\\ \end{array}\right). Among these quantum gates, $T$-gate is the only one non-Clifford gate. In the construction of QHE scheme, the main difficulty is how to devise the homomorphic evaluation of $T$-gate. The conjugate of $T$ is T^{\dagger}=\left(\begin{array}[]{cc}1&0\\ 0&e^{-i\frac{\pi}{4}}\\ \end{array}\right). All these quantum gates form a set $\mathcal{S}=\{X,Z,H,P,CNOT,T,T^{\dagger}\}$.

Because $T^{\dagger}=T^{7}$, then $T^{\dagger}$ can be implemented by seven $T$-gates. In order to simplify the description of quantum circuit, $T$ and $T^{\dagger}$ are used together in many practical quantum circuits. In the next section, we construct QHE scheme for $T$-gate and introduce how to modify it so as to implement $T^{\dagger}$ homomorphically.

For any unitary transformation $U$ and any $n$-bit string $b=b_{1}b_{2}\cdots b_{n}$, denote $U^{b}=\bigotimes_{i=1}^{n}U^{b_{i}}$, especially $U^{11\cdots 1}=\bigotimes_{i=1}^{n}U=U^{\otimes n}$.

For two $n$-bit strings $a,b\in\{0,1\}^{n}$, we define $a\oplus b=(a_{1}\oplus b_{1},a_{2}\oplus b_{2},\ldots,a_{n}\oplus b_{n})$.

From Pauli operators $X$ and $Z$, a Pauli group can be generated such as $\{X^{a}Z^{b}:a,b\in\{0,1\}^{n}\}$. Since

[TABLE]

where $\sigma$ is arbitrary quantum state and $\frac{I_{2^{n}}}{2^{n}}$ is a $n$-qubit totally mixed state. According to Eq.(1), Boykin and Roychowdhury [23] and Ambainis et al.[24] propose QOTP, which is a symmetric-key encryption scheme for quantum states. It is a kind of quantum cryptographic primitive with perfect security.

Quantum state space is usually described as a complex Hilbert space. In the quantum-message-oriented encryption scheme, the plaintext space and ciphertext space are complex Hilbert space, denoted as $\mathcal{H}_{M}$ and $\mathcal{H}_{C}$ respectively. We denote the set of density operators on the space $\mathcal{H}_{M}$ (or $\mathcal{H}_{C}$) by $D(\mathcal{H}_{M})$ (or $D(\mathcal{H}_{C})$). For a quantum state that is pure state, it can be described as a unit vector in complex Hilbert space $\mathcal{H}$; it can also be described as a density operator on space $\mathcal{H}$. In the remainder of this article, a quantum state may be a unit vector or a density operator, and we will not state it definitely since the readers can tell them apart very easily.

Given two quantum states $\rho$ and $\sigma$, their trace distance is defined as $\Delta(\rho,\sigma)=Tr(|\rho-\sigma|)$, where $|A|$ is defined as $\sqrt{A^{\dagger}A}$. A quantum channel $\Phi:D(\mathcal{A})\rightarrow D(\mathcal{B})$ is a physically-realizable mapping on quantum registers. Given a quantum circuit $QC$ with $n$-qubit input and $m$-qubit output, a quantum channel $\Phi_{QC}$ can be induced as a quantum transformation from $n$ qubits to $m$ qubits.

2.2 Gate teleportation

Gate teleportation can be seen as an extension of quantum teleportation. It is mainly applied in measurement-based quantum computing [25, 26].

Define EPR entanglement state $|\Phi_{00}\rangle=\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$, then the four Bell states can be described as

[TABLE]

For any single-qubit gate $U$, define “$U$-rotated Bell basis” as the following set

[TABLE]

where quantum state $|\Phi(U)_{ab}\rangle=(U^{\dagger}\otimes I)|\Phi_{ab}\rangle$ or $|\Phi(U)_{ab}\rangle=(U^{\dagger}Z^{b}X^{a}\otimes I)|\Phi_{00}\rangle$.

For a single-qubit state $|\alpha\rangle$, the following formula holds [26]:

[TABLE]

In fact, Eq.(4) is just a mathematical description of quantum teleportation. It can be extended as follows:

[TABLE]

where $U$ is any single-qubit gate. According to Eq.(5), if one carries out “$U$-rotated Bell measurement” (that is, $U$-rotated Bell basis $\Phi(U)$ is selected as the measurement basis in the quantum measurement) on the qubit $|\alpha\rangle$ and the first qubit of $|\Phi_{00}\rangle$, and obtains the result $a,b$, then the second qubit of $|\Phi_{00}\rangle$ would collapse into quantum state $X^{a}Z^{b}U|\alpha\rangle$. Finally, performing Pauli operator on $X^{a}Z^{b}U|\alpha\rangle$ would result in the state $U|\alpha\rangle$.

Similar to quantum teleportation, we can describe the gate teleportation: Alice and Bob preshare a pair of qubits in the state $|\Phi_{00}\rangle$; Alice prepares a qubit in the state $|\alpha\rangle$, and performs $U$-rotated Bell measurement on Alice’s local two qubits, then announces the results; According to the Alice’s results, Bob performs Pauli opertors ($X$ or $Z$ or both) and obtains a new state $U|\alpha\rangle$. The gate teleportation can be described as Fig.1.

Obviously, gate teleportation is an extension of quantum teleportation. If $U$ is the identity, then $\Phi(U)$ would be the standard Bell basis, and gate teleportation would degenerate into quantum teleportation.

3 Homomorphic evaluation of $T$-gate

In the set of universal quantum gates, $T$-gate is the only one non-Clifford gate. In order to construct QHE scheme, the main obstacle is how to homomorphically evaluate the $T$-gate. The QHE scheme in Ref.[9] realizes $T$-gate homomorphically, however an interaction are used to remove $P$-error that occurs in the homomorphic evaluation of $T$-gate: whenever Server performs a $T$-gate on a qubit, he sends the qubit to Client; Then Client performs a quantum operator $P^{x}$ ($x$ is a secret bit which is known only by Client)222In the concrete scheme, in order to protect $x$ from the eavesdropping of Server, Client should perform quantum operator $X^{r}Z^{r^{\prime}}P^{x}$, where both $r$ and $r^{\prime}$ are secret random bits chosen by Client. on the qubit and returns it to Server.

In this section, a new module named $EG[P^{x}]$ is defined, and a new method based on $EG[P^{x}]$ is proposed to remove $P$-error. Based on gate teleportation, the module $EG[P^{x}]$ is implemented through a two-party secure computation scheme, which contains quantum measurement. When the module $EG[P^{x}]$ is used in the homomorphic evaluation of $T$-gate, Client can defer all the quantum measurements until Server has finished all his/her computation. Thus the interactions can be avoided.

3.1 Encrypted gate based on gate teleportation

Define encrypted gate $EG[U]:|\alpha\rangle\rightarrow\left((a,b),Enc_{a,b}(U|\alpha\rangle)\right)$, where $a,b\in\{0,1\}$ are random bits, $Enc_{a,b}$ is a quantum encryption operator with the keys $a,b$. Especially, if $Enc_{a,b}$ is a QOTP encryption, then $EG[U]:|\alpha\rangle\rightarrow\left((a,b),X^{a}Z^{b}U|\alpha\rangle\right)$. In order to apply it to the construction of QHE, we present a two-party computation scheme for $EG[U]$ based on gate teleportation. In our scheme, Server provide a quantum state $|\alpha\rangle$ as input; While the computation of $EG[U]$ is finished, Client will obtain random bits $(a,b)$ and Server obtains the quantum state $X^{a}Z^{b}U|\alpha\rangle$; Moreover, $U$ is selected by Client, and Server cannot obtain any information about $a,b$ and $U$. For any two-party computation scheme implementing $EG[U]$, if Server can intercept zero information about $a,b$ and $U$, then we say the scheme has perfect security.

The most important feature of encrypted gate $EG[U]$ is that the computing of $U$-gate is encrypted and the gate $U$ must be secure (e.g. in the two-party computation scheme, Server cannot know which gate is selected by Client).

Fig.2 describes a gate-teleportation-based implementation of $EG[U]:|\alpha\rangle\rightarrow\left((r_{x},r_{z}),X^{r_{x}}Z^{r_{z}}U|\alpha\rangle\right)$, where $r_{x},r_{z}\in\{0,1\}$ are random bits. This implementation must use the Bell state and quantum measurement.

The detailed procedure is as follows.

Server and Client preshare quantum entanglement $|\Phi_{00}\rangle$; 2. 2.

Server sends quantum state $|\alpha\rangle$ to Client; 3. 3.

Client performs $U$-rotated Bell measurement, and obtains random results $r_{x},r_{z}\in\{0,1\}$; Then the qubit retained by Server would be in the state $X^{r_{x}}Z^{r_{z}}U|\alpha\rangle$.

Especially when $U=P^{x}$,

[TABLE]

Considering $P^{x}$-rotated Bell measurement (or quantum measurement in the basis $\{|\Phi(P^{x})_{ab}\rangle\}_{a,b\in\{0,1\}}$) on the first two qubits, if one measures two bits $a$ and $b$, then the third qubit would be in the state $X^{a}Z^{b}P^{x}|\alpha\rangle$.

According to gate teleportation, it can be easily shown the correctness of the implementation of $EG[U]$ in Fig.2. We focus on its security in the following.

Proposition 1

The two-party computation scheme of $EG[U]$ in Fig.2 is perfectly secure. That is, Server cannot obtain any information about $U$ and $r_{x},r_{z}$.

Proof

In fact, the dashed frame shows a slightly modified version of gate teleportation, so Client would obtain uniformly random bits $r_{x},r_{z}$ and Server cannot know any information about them. If the dashed frame is viewed as a black box (both Client and Server contribute to the functionality of the black box), then one can see that Client performs quantum operation $X^{r_{x}}Z^{r_{z}}U$ on Server’s quantum state $|\alpha\rangle$ and the two bits $r_{x},r_{z}\in\{0,1\}$ are unknown by Server. Thus Server does not know which gate is selected by Client, and its perfect security is derived from QOTP. Especially when $U=P^{x}$, the scheme in Fig.2 realizes the encrypted gate $EG[P^{x}]$. At the beginning of its execution, Server does not know which basis (or the value of $x$) is chosen by Client. At the end, Server cannot deduce Client’s measurement basis (or the value of $x$) from all the inputs and outputs; The reason is as follow: Client’s measurement results $r_{x},r_{z}$ are completely random and are unknown by Server, so $X^{r_{x}}Z^{r_{z}}$ can be viewed as a QOTP encryption, then the value of $x$ is perfectly hidden in the output $X^{r_{x}}Z^{r_{z}}P^{x}|\alpha\rangle$.   $\Box$

Next, we propose the detailed construction of QHE scheme for $T$-gate. In the scheme, a method to remove $P$-error is introduced based on the encrypted gate $EG[P^{x}]$, then no interaction is necessary in the homomorphic evaluation of $T$-gate.

3.2 QHE scheme for $T$-gate

QHE scheme for $T$-gate contains the following five parts: Setup, Key Generation, Encryption, Evaluation of $T$-gate, and Decryption, where Setup preshares Bell state between Client and Server, and Key Generation generates encryption key (or secret key). The decryption key is generated until the key-updating procedure in Decryption. In the Decryption, Client should perform quantum measurement using the secret key; Then Client updates the secret key according to the key-updating rule and measurement result; Finally, Client obtains the decryption key (or final key).

In the following scheme, the first qubit of $|\Phi_{00}\rangle$ is relabeled as $c$, and the other as $s$. Then this Bell state is denoted by $|\Phi_{00}\rangle_{c,s}$.

QHE scheme for $T$-gate

1.Setup:

EPR source generates Bell state $|\Phi_{00}\rangle_{c,s}$, where qubit $c$ and qubit $s$ are held by Client and Server, respectively.

2.Key Generation:

Generate random bits $x,z\in\{0,1\}$, and output $sk=(x,z)$ as secret key.

3.Encryption:

Given a single-qubit input, Client performs QOTP encryption with secret key $sk=(x,z)$. For example $|\alpha\rangle\rightarrow X^{x}Z^{z}|\alpha\rangle$.

4.Evaluation of $T$-gate:

Server performs $T$-gate on encrypted qubit, and then a quantum $\mathrm{SWAP}$ operation on that qubit and qubit $s$, and finally outputs both of them.

5.Decryption:

According to secret key $sk=(x,z)$, Client carries out quantum measurement and key-updating, and obtains a new key which can be used as the decryption key.

5-1.Quantum measurement.

According to the key $x$, Client performs $P^{x}$-rotated Bell measurement on qubit $s$ and qubit $c$, and obtains random values $(r_{x},r_{z})$.

5-2.Key-updating.

From the key-updating rules (Appendix C) and the secret key $sk=(x,z)$ and measurement result $(r_{x},r_{z})$, Client computes the new key $(x^{\prime},z^{\prime})=(x\oplus r_{x},x\oplus z\oplus r_{z})$.

5-3.QOTP decryption.

With the new key $(x^{\prime},z^{\prime})$, Client performs QOTP decryption on the encrypted result and obtains the plaintext result. For example $|\varphi\rangle\rightarrow Z^{z^{\prime}}X^{x^{\prime}}|\varphi\rangle=T|\alpha\rangle$.

QHE scheme for $T$-gate can be described as Fig.3.

In Fig.3, the dashed circle shows the two-party computation scheme of encrypted gate $EG[P^{x}]$, which would output $((r_{x},r_{z}),X^{r_{x}}Z^{r_{z}}P^{x}TX^{x}Z^{z}|\alpha\rangle)$. The classical bits $(r_{x},r_{z})$ are the partial inputs for the key-updating procedure, and the quantum state is the encrypted result. There are three transmissions of messages in the whole scheme. The first and third messages are encrypted data and encrypted result, respectively. So there is only one transmission in the homomorphic evaluation. Concretely, there is an unidirectional transmission from Server to Client in the execution of $EG[P^{x}]$.

The two bits $x,z\in\{0,1\}$ are Client’s secret key, and are unknown by Server. Client’s quantum measurement depends on the secret bit $x$ and the measurement basis is $\{|\Phi(P^{x})_{ab}\rangle\}_{a,b\in\{0,1\}}$. In addition, Client’s outputs $r_{x},r_{z}$ in the measurement are completely random, and would not be sent to Server, so Server cannot obtain the secret key $x,z$ and the new key $(x^{\prime},z^{\prime})$, where $x^{\prime}=x\oplus r_{x},z^{\prime}=x\oplus z\oplus r_{z}$.

3.3 Analysis

In the above scheme, the implementation of $EG[P^{x}]$ (in the dashed circle) contains quantum measurement. According to the principal of deferred measurement, Client could defer the $P^{x}$-rotated Bell measurement until Server returns the result of homomorphic evaluation. While measuring the qubit $s$ and qubit $c$, Client obtains the encrypted result $X^{x^{\prime}}Z^{z^{\prime}}T|\alpha\rangle$ and two random bits $(r_{x},r_{z})$. Then Client can update the secret key $(x,z)$ according to $(r_{x},r_{z})$ and obtain a new secret key $(x^{\prime},z^{\prime})$, which is used to decrypt the encrypted result.

In Fig.3, there are three arrows, which represent the 1st, 2nd, and 3rd information transmission, respectively. Both the 2nd and 3rd transmissions are from Server to Client. Because the quantum measurement can be deferred until Server returns the final result of homomorphic evaluation, the 2nd message can be incorporated into the 3rd transmission. Then the whole scheme contains only two information transmissions, and no interaction is necessary during the phase of homomorphic evaluation.

Proposition 2

The QHE scheme for $T$-gate is correct. That is, $T$-gate can be implement homomorphically.

Proof

The phase of evaluation contains a $\mathrm{SWAP}$ operation, and the phase of decryption contains a quantum measurement. The two operations have just finished the encrypted gate $EG[P^{x}]$. It is easy to verify the following equation (up to a global phase):

[TABLE]

So (up to a global phase)

[TABLE]

where $r_{x},r_{z}\in\{0,1\}$ and $|\alpha\rangle$ is arbitrary qubit. While finishing the $EG[P^{x}]$, Client would obtain $(r_{x},r_{z})$ and Server would obtain a qubit in the encrypted state $X^{x^{\prime}}Z^{z^{\prime}}T|\alpha\rangle$, where the new key $(x^{\prime},z^{\prime})=(x\oplus r_{x},x\oplus z\oplus r_{z})$; However, Server does not know the value of the new key $(x^{\prime},z^{\prime})$. Then Server sends the encrypted state to Client. Finally, Client firstly computes the new key $(x^{\prime},z^{\prime})$ from the his/her secret key $sk=(x,z)$ and measurement result $r_{x},r_{z}$ and then decrypts the encrypted state and obtains plaintext result $T|\alpha\rangle$.   $\Box$

Proposition 3

The QHE scheme for $T$-gate is perfectly secure.

Proof

The security is guaranteed by the security of QOTP and $EG[P^{x}]$. Concretely, Client performs QOTP encryption on quantum data $|\alpha\rangle$ and sends the encrypted data to Server, so Server cannot obtain any information about the plaintext data $|\alpha\rangle$ and random bits $x,z$. Next, Server collaborates with Client and finishes the computation of $EG[P^{x}]$. Because Proposition 1 has proved the perfect security of the two-party computation scheme for $EG[P^{x}]$, Server cannot obtain any information about $x$ and $r_{x},r_{z}$ during the computation of $EG[P^{x}]$. Above all, Server cannot obtain any information about $|\alpha\rangle$, $(x,z)$ and $(r_{x},r_{z})$, so the final key $(x^{\prime},z^{\prime})$ is also perfectly protected. Then, with respect to Server, the computation result $T|\alpha\rangle$ is perfectly hidden in the encrypted result $X^{x^{\prime}}Z^{z^{\prime}}T|\alpha\rangle$.   $\Box$

It can be seen from the QHE scheme for $T$-gate that, Server only performs $T$-gate and $\mathrm{SWAP}$, and Client performs more complex quantum computation (e.g. $X$,$Z$,$CNOT$,$P$,$H$,$Z$-basis measurement); However, this QHE scheme is only customized to the homomorphic evaluation of $T$-gate. For a general quantum circuit which contains lots of different gates, we will construct its QHE scheme and compare Client’s quantum complexity and Server’s.

Remark 1

For a $T^{\dagger}$-gate, its QHE scheme can be constructed in the same way, and the proofs of correctness and security are also the same. The only difference lies in that, key-updating algorithm will obtain the new key $(x^{\prime},z^{\prime})=(x\oplus r_{x},z\oplus r_{z})$.

In the next section, QHE schemes for any unitary quantum circuit are presented based on the scheme that implements $T/T^{\dagger}$-gate homomorphically. Once that Server performs a $T/T^{\dagger}$-gate, he/she should collaborate with Client and finishes an execution of $EG[P^{x}]$ (the bit $x\in\{0,1\}$ is an intermediate value during the process of key-updating. It is only known by Client, so the collaboration of Server and Client is necessary for the execution of $EG[P^{x}]$). Thus, once a $T/T^{\dagger}$-gate is performed, an unidirectional transmission from Server to Client is required. In the whole QHE scheme for quantum circuit, the total number of transmissions is the same as that of $T/T^{\dagger}$-gate in the circuit. In fact, all these transmissions can be deferred until finishing all the homomorphic evaluation of the circuit, then the interactions in the homomorphic evaluation procedure can be completely avoided.

4 Quantum homomorphic encryption scheme for any unitary quantum circuit

In the QHE scheme for $T/T^{\dagger}$-gate, based on $EG[P^{x}]$, a non-interactive method is proposed to remove $P$-error generated in the homomorphic evaluation. Moreover, using the method, we devise two QHE schemes for any unitary quantum circuit. Our schemes have the following properties: non-interaction, perfect security, homomorphic evaluation of any unitary quantum circuit, and quasi-compactness. The first scheme GT achieves $M\log M$-quasi-compactness, and its variation VGT achieves $M$-quasi-compactness.

4.1 Main idea

According to the QHE scheme for $T$-gate, once that Server performs a $T$-gate, Server and Client should finish a two-party computation scheme of $EG[P^{x}]$. The implementation of $EG[P^{x}]$ contains quantum measurement, and the measurement depends on the secret bit $x$. Given a quantum circuit $\mathcal{C}$ which has $M$ $T/T^{\dagger}$-gates, if each $T/T^{\dagger}$-gate is implemented homomorphically following the previous scheme, then the QHE scheme for $\mathcal{C}$ would contain $M$ quantum measurements. We prove all the $M$ measurements can be deferred until Server has finished the evaluation of quantum circuit $\mathcal{C}$.

Without loss of generality, we consider a quantum circuit with at least one $T$-gate (see Fig.4). The circuit contains a $T$-gate acting on the 1st qubit, and then any sub-circuit $\Omega$ acting on $n(n\geq 1)$ qubits, where $\Omega$ may contains more $T$-gates. $\Omega$ may be only one quantum gate, or a series of gates; $\Omega$ maybe act on only one qubit (if $n=1$, then $\Omega$ acts on only one qubit, and acts on the same qubit as $T$-gate), or act on $n$ qubits.

Given a quantum circuit containing $T$-gates (see Fig.4), we consider that the $T$-gate is implemented homomorphically using the previous scheme. Concretely, the encrypted data $X^{x}Z^{z}|\alpha\rangle$ is transformed by $T$, and then $EG[P^{x}]$ performs on it and Bell state. We prove that, the measurement ($P^{x}$-rotated Bell measurement) in the module $EG[P^{x}]$ can be deferred until finishing the computation of the quantum circuit $\Omega$ (see Fig.5).

In Fig.5, there are four quantum registers. In order to explicitly describe the following deduction, these registers are denoted as $1,2,s,c$, respectively. The 2nd register has $n-1$ qubits. In the following formulas, the subscript of a quantum operator indicates which register is performed by the quantum operator, and the subscript of a quantum state indicates which register is in that state.

[TABLE]

Thus the final result is $\left((r_{x},r_{z}),\Omega(X^{x\oplus r_{x}}Z^{x\oplus z\oplus r_{z}}T|\alpha\rangle\otimes|\beta\rangle)\right)$. Next we consider the condition that the quantum measurement ($P^{x}$-rotated Bell measurement) in $EG[P^{x}]$ is not deferred. Concretely, $T$-gate is firstly performed and then followed by $EG[P^{x}]$, e.g.$EG[P^{x}]TX^{x}Z^{z}|\alpha\rangle=\left((r_{x},r_{z}),X^{x\oplus r_{x}}Z^{x\oplus z\oplus r_{z}}T|\alpha\rangle\right)$, and the sub-circuit $\Omega$ is performed finally and the first two registers come into the state $\left((r_{x},r_{z}),\Omega(X^{x\oplus r_{x}}Z^{x\oplus z\oplus r_{z}}T|\alpha\rangle\otimes|\beta\rangle)\right)$. Thus, the final result would not be affected whether or not deferring the quantum measurement in $EG[P^{x}]$.

Similar to the analysis about $T$-gate, we can obtain the same conclusion for the $T^{\dagger}$-gate.

For a quantum circuit $\mathcal{C}$ which contains $M$ $T/T^{\dagger}$-gates, we can recursively make use of the above method: each $T/T^{\dagger}$-gate is performed and followed by a encrypted gate $EG[P^{x}]$, where the secret bit $x$ varies every time; There are $M$ $T/T^{\dagger}$-gates and $M$ encrypted gates; These encrypted gates contains $M$ quantum measurements; All these measurements can be deferred until finishing the whole circuit $\mathcal{C}$. The quantum measurement in $EG[P^{x}]$ depends on the updating intermediate key $x$ before the execution of $T/T^{\dagger}$-gate, and the key-updating rule of $T/T^{\dagger}$-gate depends on the measurement result in the previous measurements. So all these $M$ quantum measurements must be performed alternately with the key-updating steps. (There are two alternative ways and each one results a version of QHE scheme in this article). In addition, the key-updating steps has the same order as the series of quantum gates, so all these $M$ measurements are performed in the same order as the execution of all $M$ $T/T^{\dagger}$-gates.

4.2 Scheme GT QHE scheme based on gate teleportation

According to the above idea, we propose a non-interactive QHE scheme, in which the encryption algorithm is QOTP-encryption. In the homomorphic evaluation of quantum circuit $\mathcal{C}$, Server carries out a series of quantum gates in circuit $\mathcal{C}$ except that performing an additional $\mathrm{SWAP}$ operation after each execution of $T/T^{\dagger}$-gate. There is no interaction between Client and Server during the process of homomorphic evaluation. In the process of decryption, Client alternately performs quantum measurements and key-updating, and finally performs a QOTP-decryption. There is no interaction between Client and Server during the decryption. The detailed description is presented as follows.

Suppose there is a unitary quantum circuit $\mathcal{C}$ acting on $n$ qubits. Assume it consists of the quantum gates from the set $\mathcal{S}=\{X,Z,H,P,CNOT,T,T^{\dagger}\}$, and its size is $N$ (There are $N$ gates in the circuit). The quantum gates in $\mathcal{C}$ are numbered from left to right, e.g. $Gate[1]$, $Gate[2]$, $\ldots$, $Gate[N]$. Denote $Gate[j]_{w}$ as the $j$th quantum gate acting on the $w$th qubit. For example, $Gate[j]=H$ acts on the $w$th qubit, denote $Gate[j]_{w}=H_{w}$ or $Gate[j]=H_{w}$. Denote $CNOT_{w,w^{\prime}}$ as a two-qubit gate $CNOT$ acting on the $w$th and $w^{\prime}$th qubits, where $w$th qubit is the control). Among the $N$ gates, assume the total number of $T$-gates and $T^{\dagger}$-gates is $\sharp\{j:Gate[j]=T\texttt{ or }T^{\dagger}\}=M$. Every $T$-gate and $T^{\dagger}$-gate has its own number $j_{i}$ ($i\leq j_{i}\leq N$, $1\leq i\leq M$) in the series of gates $\{Gate[j],j=1,\ldots,N\}$. Then $Gate[j_{i}]=T/T^{\dagger}$ and $j_{i}<j_{i+1}$. Suppose $Gate[j_{i}]$ ($1\leq i\leq M$) acts on $w_{i}$th qubit ($1\leq w_{i}\leq n$). That is, $Gate[j_{i}]=T_{w_{i}}/T_{w_{i}}^{\dagger}$.

Next we describe the QHE scheme GT for the quantum circuit $\mathcal{C}$. The encryption algorithm is the QOTP encryption transformation; the plaintext data has $n$ qubits and the secret key $sk$ has $2n$ bits. Let QOTP key $sk=(x_{0},z_{0}),x_{0},z_{0}\in\{0,1\}^{n}$. The $w$th plaintext qubit is encrypted using the secret bit $(x_{0}(w),z_{0}(w))$. Once that a quantum gate is performed on an encrypted data, the QOTP key should be updated according to the key-updating rules (see Appendix C). After the $j$th ($1\leq j\leq N-1$) gate is performed, a new key (denoted as $(x_{j},z_{j}),x_{j},z_{j}\in\{0,1\}^{n}$) can be obtained through key-updating; It is nether the initial key nor final key, so we call it intermediate key. After the execution of the final gate and all the key-updating, a final key $(x_{final},z_{final})$ can be obtained, and can be used in QOTP decryption. It is worth to notice that, only the server knows the quantum circuit $\mathcal{C}$ (or the series of gates in $\mathcal{C}$), so Server must generate the key-updating functions according to the key-updating rules and the gates’ sequence, and the key-updating functions should be sent to Client together with the encrypted results. Client computes the final key $(x_{final},z_{final})$ using the key-updating functions.

QHE scheme GT for quantum circuit $\mathcal{C}$ can be described as the five parts: Setup, Key Generation, Encryption, Evaluation, and Decryption. In our scheme, Setup is an additional part compared with the usual definition of QHE. It preshares Bell states between Client and Server. Actually, these Bell states can be generated during the evaluation, e.g. before each $\mathrm{SWAP}$ operation. In the QHE scheme, the first half of the $i$th Bell state is relabeled as $c_{i}$, and the other as $s_{i}$. Then the $i$th Bell state is denoted as $|\Phi_{00}\rangle_{c_{i},s_{i}}$, $i=1,\ldots,M$.

Scheme GT QHE scheme based on gate teleportation

1.Setup:

$\texttt{GT.Setup}(1^{M})$. Generate $M$ Bell states $\{|\Phi_{00}\rangle_{c_{i},s_{i}},i=1,\ldots,M\}$ as the ancillary states, where qubits $c_{i},i=1,\ldots,M$ and qubits $s_{i},i=1,\ldots,M$ are kept by Client and Server, respectively.

2.Key Generation:

$\texttt{GT.KeyGen}(1^{n})$. Generate random bits $x_{0},z_{0}\in\{0,1\}^{n}$, and output $sk=(x_{0},z_{0})$ as the secret key.

3.Encryption:

$\texttt{GT.Enc}(sk,\sigma)$. For any $n$-qubit data $\sigma$, Client performs QOTP encryption with the secret key $sk=(x_{0},z_{0})$, e.g. $\sigma\rightarrow\rho=X^{x_{0}}Z^{z_{0}}\sigma Z^{z_{0}}X^{x_{0}}$.

4.Evaluation:

$\texttt{GT.Eval}\left(\mathcal{C},\{\mathrm{qubit}s_{i}\}_{i=1}^{M},\rho\right)$. Server should carry out the following two steps.

4-1.Quantum computation.

With the help of the ancillary qubits $s_{i}$, $i=1,\ldots,M$, Server carries out the quantum gates $Gate[1],Gate[2],\ldots,Gate[N]$ on the $n$-qubit encrypted data $\rho$. For each $j\in\{1,\ldots,N\}$, there are two cases as follows.

4-1-a

When $j\notin\{j_{1},\ldots,j_{M}\}$, that means $Gate[j]\notin\{T,T^{\dagger}\}$, then Server carries out quantum gate $Gate[j]$;

4-1-b

When $j=j_{i}(1\leq i\leq M)$, that means $Gate[j]=Gate[j_{i}]=T_{w_{i}}$ or $T_{w_{i}}^{\dagger}$, then Server firstly performs quantum gate $Gate[j]$ on the qubit $w_{i}$ and then performs swap operation $\mathrm{SWAP}(\texttt{qubit}w_{i},\texttt{qubit}s_{i})$.

4-2.Generating $M+1$ key-updating functions $\{g_{i}\}_{i=1}^{M}$ and $f$.

4-2-a

According to key-updating rules, Server generates the polynomial $\{g_{i}\}_{i=1}^{M}$ for one key bit $x_{j_{i}-1}(w_{i})\in\{0,1\}$. Denote it as

$x_{j_{i}-1}(w_{i})=\begin{cases}g_{1}(x_{0},z_{0}),\texttt{if }i=1;\\ g_{i}(x_{0},z_{0},r_{x}(1),r_{z}(1),\ldots,r_{x}(i-1),r_{z}(i-1)),\\ \texttt{ if }i=2,\ldots,M.\end{cases}$

(17)

4-2-b

According to key-updating rules, Server generates the polynomial $f$ for the final key $(x_{final},z_{final})\in\{0,1\}^{2n}$. Denote it as

$(x_{final},z_{final})=f(x_{0},z_{0},r_{x}(1),r_{z}(1),\ldots,r_{x}(M),r_{z}(M)).$

(18)

After finishing the steps (4-1)(4-2), Server outputs the $n$-qubit encrypted result $\rho^{\prime}$ and all the ancillary qubits $s_{i},i=1,\ldots,M$, together with all the key-updating functions $f$ and $\{g_{i}\}_{i=1}^{M}$.

Scheme GT continued

5.Decryption:

$\texttt{GT.Dec}\left(sk,\{g_{i}\}_{i=1}^{M},f,\{\mathrm{qubit}s_{i},\mathrm{qubit}c_{i}\}_{i=1}^{M},\rho^{\prime}\right)$. According to secret key $sk=(x_{0},z_{0})$ and all the key-updating functions, Client performs quantum measurements on the $M$ pairs of qubits $\{(s_{i},c_{i})\}_{i=1}^{M}$, and QOTP-decryption on the $n$-qubit encrypted result $\rho^{\prime}$. The detailed procedure has the following three steps.

5-1.Alternate execution of $\{g_{i}\}_{i=1}^{M}$-computing and measurement.

For each $i=1,\ldots,M$, Client finishes $i$th round of computation which contains the two steps.

5-1-a.Computing measurement basis $\Phi(P^{b})$.

According to secret key $sk=(x_{0},z_{0})$ and part of measurement results $r_{x}(1),r_{z}(1),\ldots,r_{x}(i-1),r_{z}(i-1)$, Client computes a key bit $b$ from the key-updating function $g_{i}$

$b=\begin{cases}g_{1}(x_{0},z_{0}),\texttt{if }i=1;\\ g_{i}(x_{0},z_{0},r_{x}(1),r_{z}(1),\ldots,r_{x}(i-1),r_{z}(i-1)),\\ \texttt{ if }i=2,\ldots,M.\end{cases}$

(19)

5-1-b.Quantum measurement.

Based on the measurement basis $\Phi(P^{b})$, Client performs quantum measurement on the qubit $c_{i}$ and qubit $s_{i}$, and obtains the measurement result $m_{x},m_{z}\in\{0,1\}$. Let $(r_{x}(i),r_{z}(i))=(m_{x},m_{z})$.

Alternately perform $M$ rounds of the two steps (5-1-a) and (5-1-b), and finally obtain all the measurement results $\{r_{x}(i),r_{z}(i)\}_{i=1}^{M}$.

5-2.Computing the final key $(x_{final},z_{final})$.

The secret key $sk=(x_{0},z_{0})$ and all the measurement results $\{r_{x}(i),r_{z}(i)\}_{i=1}^{M}$ are inputted into the function $f$, and the computation generates the final key $(x_{final},z_{final})$.

5-3.QOTP decryption.

According to the final key $(x_{final},z_{final})$, Client performs QOTP decryption transformation on the encrypted result, e.g. $\rho^{\prime}\rightarrow\sigma^{\prime}=Z^{z_{final}}X^{x_{final}}\rho^{\prime}X^{x_{final}}Z^{z_{final}}$.

In the scheme GT, the measurement basis depends on one bit of some intermediate key, and the key bit should be computed from the key-updating functions $\{g_{i}\}_{i=1}^{M}$, which relate to the measurement results. Thus, Client must alternately perform quantum measurements and key-updating functions, and obtains the final key. The number of alternations is the same as the number of $T/T^{\dagger}$-gates in the circuit $\mathcal{C}$.

According to the above QHE scheme, all the quantum measurements are deferred until finishing the execution of all the quantum gates $\{Gate[j]\}_{j=1}^{N}$. Thus, both Server and Client need $M$-qubit quantum memory in order to temporarily store qubits $s_{i}$ and qubits $c_{i}$. When Server returns the encrypted result, the qubits $s_{i},i=1,\ldots,M$ are also sent back to Client. Client performs quantum measurements on each pair of qubits $(s_{i},c_{i})$, and the measurement basis is computed from his/her secret key $sk=(x_{0},z_{0})$ and the key-updating functions, which are provided by Server.

4.3 Analysis

The scheme GT is analyzed from the correctness, security and quasi-compactness.

Theorem 4.1

Scheme GT is correct. That is, let $\mathcal{F}$ be the class of all unitary quantum circuits consisted of quantum gates in $\mathcal{S}=\{X,Z,H,P,CNOT,T,T^{\dagger}\}$, the scheme GT is $\mathcal{F}$-homomorphic.

Proof

It is sufficient to prove that, for any $n$-qubit unitary circuit $\mathcal{C}$ and any $n$-qubit data $\sigma$,

[TABLE]

where the quantum circuit $\mathcal{C}$ consists of the gates $Gate[1]$,$Gate[2]$,$\ldots$,$Gate[N]$, and $\sharp\{j|Gate[j]\in\{T,T^{\dagger}\}\}=M$.

In the scheme GT, for each $Gate[j_{i}]\in\{T,T^{\dagger}\}$, its homomorphic evaluation is realized by using encrypted gate $EG(P^{x_{j_{i}-1}(w_{i})})$, where $w_{i}$ indicates the qubit which the $Gate[j_{i}]$ acts on. The implementation of $EG(P^{x_{j_{i}-1}(w_{i})})$ contains two parts — $\mathrm{SWAP}$ and quantum measurement, which are finished in GT.Eval and GT.Dec respectively. The measurement in GT.Dec depends on one bit of the intermediate key. If the intermediate key is correct, then $EG(P^{x_{j_{i}-1}(w_{i})})$ can be implemented correctly.

In the following, we prove the intermediate keys and final key can be computed correctly. According to Section 4.1, there exists no effect on the final result whether or not defer the measurement part of $EG(P^{x_{j_{i}-1}(w_{i})})$. Thus, for convenient to prove our result, we assume that all the two parts of $EG(P^{x_{j_{i}-1}(w_{i})})$ are finished in GT.Eval and all the measurement results $r_{x}(1)$,$r_{z}(1)$,$\ldots$,$r_{x}(M)$,$r_{z}(M)$ are obtained in GT.Eval.

The algorithm GT.Eval performs quantum computing on encrypted data $X^{x_{0}}Z^{z_{0}}\sigma Z^{z_{0}}X^{x_{0}}$ according to the order of the quantum gates $Gate[j]$,$j=1,\ldots,N$. Synchronically, GT.Eval derives key-updating functions $\{g_{i}\}_{i=1}^{M}$ and $f$ according to key-updating rules. The correctness of the key-updating rules can ensure that each intermediate key $(x_{i},z_{i})$ and final key $(x_{final},z_{final})$ can be computed correctly from the algorithm GT.Dec and the initial key $sk=(x_{0},z_{0})$. Then the encrypted result generated by $\texttt{GT.Eval}\left(\mathcal{C},\{\mathrm{qubit}s_{i}\}_{i=1}^{M},X^{x_{0}}Z^{z_{0}}\sigma Z^{z_{0}}X^{x_{0}}\right)$ is just

[TABLE]

where $(x_{final},z_{final})=f(x_{0},z_{0},r_{x}(1),r_{z}(1),\ldots,r_{x}(M),r_{z}(M))$. Finally the decryption would output the plaintext result $\Phi_{\mathcal{C}}(\sigma)$, so

[TABLE]

$\Box$

Theorem 4.2

Scheme GT is perfectly secure.

Proof

Firstly, the algorithm GT.Enc is a QOTP encryption transformation, so it can perfectly encrypt the plaintext and the secret key $sk=(x_{0},z_{0})$ is also hidden perfectly. During the evaluation procedure, there is no interaction between Server and Client, so Server cannot obtain any information about the plaintext and the key.

Secondly, during the decryption procedure, Client carries out some classical computation and quantum measurements, and there is no interaction in the computation. Then Client’s classical computation would reveal no information. Each measurement is part of an encrypted gate, which has been proved to be perfectly secure in Proposition 1, thus Client’s quantum measurements would reveal no information too.

Finally, Client obtains the perfectly secure final key and performs QOTP decryption which is also perfectly secure. Thus, the scheme GT is perfectly secure.    $\Box$

Theorem 4.3

Scheme GT is a QHE scheme with $M\log M$-quasi-compactness.

Proof

In the algorithm GT.Eval, Server should generate $M+1$ key-updating functions

[TABLE]

Each key-updating function can be expressed with the XOR of some binary variables. Then, the computational complexity of $g_{i}$ is at most $\log_{2}(2n+2(i-1))$, $i=1,\ldots,M$ and the computational complexity of $f$ is at most $2n\log_{2}(2n+2M)$. Thus, the classical complexity of decryption procedure is at most $2n\log_{2}(2n+2M)+\sum_{i=1}^{M}\log_{2}(2n+2(i-1))=O((M+n)\log_{2}(M+n))$. The decryption procedure contains $M$ quantum measurements and $n$-qubit QOTP decryption, so its quantum complexity is $M+2n$. So time complexity of GT.Dec is $O((M+n)\log_{2}(M+n))$. Thus the dependence of the complexity of GT.Dec on the evaluated circuit $\mathcal{C}$ is $M\log M$.    $\Box$

Scheme GT has the following features.

If the quantum data has $n$ qubits, then the secret key has $2n$ qubits and the encrypted data has $n$ qubits, and the encrypted result obtained by GT.Eval preserves the same size as the encrypted data. 2. 2.

The number of Bell states is the same as that of $T/T^{\dagger}$ in $\mathcal{C}$. 3. 3.

There are $M$ “rotated Bell measurements”, which generate $2M$ classical bits. 4. 4.

The evaluation key is not necessary in the algorithm GT.Eval. 5. 5.

During the key-updating procedure (step 5-1), all the intermediate keys are not stored. Every intermediate key and the final key have the same size as the secret key. 6. 6.

Client must know the total number $M$ of $T/T^{\dagger}$-gates in Server’s circuit $\mathcal{C}$. The number determines how many times Client would perform quantum measurements. 7. 7.

It is unnecessary for Client to know any information of Server’s quantum circuit $\mathcal{C}$, except the total number of $T/T^{\dagger}$-gates.

Remark 2

In GT.Setup, Client and Server preshares $M$ Bell states, where $M$ is the total number of $T/T^{\dagger}$-gates. Actually, it is unnecessary for them to preshare Bell states. Instead, the Bell state can be produced by Server whenever he/she performs a $T/T^{\dagger}$-gate during the evaluation procedure. Moreover, Server could produce as many Bell states as required. Finally Server’s qubits are all sent back to Client together with the encrypted result.

4.4 Scheme VGT: a variation of GT with optimal quasi-compactness

In this section, the scheme GT is slightly modified and a variation named VGT is presented. Before we describe the scheme VGT, we prove an optimal quasi-compactness bound. Finally the scheme VGT can achieve this optimal bound.

Theorem 4.4

For any non-interactive and $\mathcal{F}$-homomorphic QHE scheme with perfect security, it must be quasi-compact and $M$-quasi-compactness is the optimal bound.

Proof

For any QHE scheme QHE={QHE.KeyGen,QHE.Enc,QHE.Eval,QHE.Dec} with no interaction, Client and Server must finish the following three stages. There are only two transmissions, where the first one is in the stage 1 and the second one is in the stage 2.

Stage 1.

Client performs the algorithm QHE.Enc on quantum data, and sends the encrypted data to Server;

Stage 2.

Server performs the homomorphic evaluation QHE.Eval, and sends the encrypted result to Client;

Stage 3.

Client performs the algorithm QHE.Dec on the encrypted result, and obtains the plaintext result.

All these stages are analyzed one by one.

Stage 1.

Because QHE is required to be perfectly secure, QHE.Enc must adopt QOTP encryption transformation, and the secret key $sk$ would not be revealed. Thus, Server cannot obtain any information about the secret key from the first transmission.

Stage 2.

Because QHE is $\mathcal{F}$-homomorphic, it must allow the homomorphic evaluation of $T$-gate. In the homomorphic evaluation QHE.Eval, once that a $T$-gate is executed on the encrypted data, a key-dependent $P$-error would occur. If Server’s quantum circuit $\mathcal{C}$ contains $M$ $T$-gates, then the algorithm QHE.Eval would cause $M$ $P$-errors, and each $P$-error is controlled by a different bit of certain intermediate key. In Stage 1, Server cannot obtain any information about the secret key, so he/she cannot correct the $M$ $P$-errors. Thus, the encrypted result in Stage 2 has $M$ $P$-errors, and the $M$ $P$-errors are inevitably continued to Stage 3.

Stage 3.

In the algorithm QHE.Dec, the $M$ $P$-errors must be corrected. Each $P$-error depends on the value of a different bit in certain intermediate key. That means, the $M$ $P$-errors are controlled by $M$ intermediate keys (Denote them as $key_{j}$,$j=1,\ldots,M$). According to key-updating rules, there exists logically computational relations between these different keys (Concretely there exists a family of functions $\{h_{j}\}_{j=1}^{M}$ which satisfy the relations $key_{j}=h_{j}(key_{j-1}),j\in\{1,\ldots,M-1\}$, where $key_{0}$ is the secret key $sk$), and these relations $\{h_{j}\}_{j=1}^{M}$ are determined by the quantum circuit $\mathcal{C}$. Thus, in the second transmission, these relations $\{h_{j}\}_{j=1}^{M}$ must be included in the message beside the encrypted result. So Client must finish at least $M$ steps of computation in order to obtains these $M$ keys, and finally carries out the correction of $M$ $P$-errors. Moreover, these keys are sequentially dependent, e.g. $key_{j}=h_{j}(key_{j-1})$, so the $M$ steps of computation cannot be executed in parallel. Instead, they must be finished one by one. Thus the time complexity of QHE.Dec must be dependent on $M$, and is at least $O(M)$.

Thus, for any non-interactive and $\mathcal{F}$-homomorphic QHE scheme with perfect security, $M$-quasi-compactness is the optimal bound.    $\Box$

Next we present the variation VGT of the scheme GT. Scheme VGT is a QHE scheme with $M$-quasi-compactness, and its security is the same as GT.

Compared to GT, the scheme VGT’s differences only exist in the evaluation and decryption procedures. So we only describe the modified parts in the algorithms VGT.Eval and VGT.Dec. Let $j_{0}=0$ in the following description.

The evaluation procedure of VGT is expressed with $\texttt{VGT.Eval}(\mathcal{C},\{\mathrm{qubit}s_{i}\}_{\{}i=1\}^{M},\rho)$. Concretely, the step $(\textbf{4-2})$ in GT.Eval is replaced with the step $(\textbf{4-2}^{\prime})$ as follows.

$\textbf{4-2}^{\prime}$.

Generating $2M+1$ key-updating functions $\{g_{i}\}_{i=1}^{M}$ and $\{f_{i}\}_{i=1}^{M+1}$.

4-2′-a.**

According to key-updating rules, Server generates the polynomial $\{g_{i}\}_{i=1}^{M}$ for one key bit $x_{j_{i}-1}(w_{i})\in\{0,1\}$. Denote it as

$x_{j_{i}-1}(w_{i})=g_{i}(x_{j_{i-1}},z_{j_{i-1}}),i=1,\ldots,M.$

(22)

4-2′-b.**

According to key-updating rules, Server generates the polynomial $\{f_{i}\}_{i=1}^{M}$ for the intermediate key $(x_{j_{i}},z_{j_{i}})\in\{0,1\}^{2n}$. Denote it as

$(x_{j_{i}},z_{j_{i}})=f_{i}(x_{j_{i-1}},z_{j_{i-1}},r_{x}(i),r_{z}(i)),i=1,\ldots,M.$

(23)

4-2′-c.**

According to key-updating rules, Server generates the polynomial $f_{M+1}$ for the final key $(x_{final},z_{final})\in\{0,1\}^{2n}$. Denote it as

$(x_{final},z_{final})=f_{M+1}(x_{j_{M}},z_{j_{M}}).$

(24)

The decryption procedure of VGT is expressed with

[TABLE]

Concretely, the steps (5-1) and (5-2) in GT.Dec are replaced with the steps (5-1*′) and (5-2′*) as follows.

5-1′.Alternate execution of key-updating and measurement.**

For $i=1$ to $M$, Client finishes the computation (5-1*′-a)(5-1′-b)(5-1′*-c) (or “$g_{i}$-measurement-$f_{i}$” in brief). Finally Client obtains the intermediate key $(x_{j_{M}},z_{j_{M}})$.

5-1′-a. Compute $g_{i}$ and obtain measurement basis $\Phi(P^{b})$.**

According to the key $(x_{j_{i-1}},z_{j_{i-1}})$ and the key-updating function $g_{i}$, Client computes a key bit $b=g_{i}(x_{j_{i-1}},z_{j_{i-1}})$. (When $i=1$, $(x_{j_{i-1}},z_{j_{i-1}})$ is the secret key $sk=(x_{0},z_{0})$.)

5-1′-b. Quantum measurement.**

Based on the measurement basis $\Phi(P^{b})$, Client performs quantum measurement on $\mathrm{qubit}c_{i}$ and $\mathrm{qubit}s_{i}$, and obtains the measurement result $m_{x}$,$m_{z}$. Let $(r_{x}(i),r_{z}(i))=(m_{x},m_{z})$.

5-1′-c. Compute $f_{i}$ and update the key.**

According to the key-updating function $f_{i}$, Client computes the intermediate key $(x_{j_{i}},z_{j_{i}})=f_{i}(x_{j_{i-1}},z_{j_{i-1}},r_{x}(i),r_{z}(i))$.

5-2′.**

According to the intermediate key $(x_{j_{M}},z_{j_{M}})$, Client computes $f_{M+1}$ and obtains the final key $(x_{final},z_{final})$.

Theorem 4.5

Scheme VGT is a correct and perfectly secure QHE scheme.

Proof

Compare VGT with GT, the only variation is that they generate the key-updating functions in different ways. It would not affect the correctness and security of the QHE scheme, and the proof is very similar to GT. The details are omitted here.    $\Box$

Finally, we prove the scheme VGT achieves the optimal quasi-compactness.

Theorem 4.6

Scheme VGT is a QHE scheme with $M$-quasi-compactness.

Proof

According to the scheme VGT, Server should generate $2M+1$ key-updating functions in the evaluation procedure.

[TABLE]

Each key-updating function can be expressed with the XOR of some binary variables. Then, the computational complexity of $g_{i}$ is at most $\log_{2}(2n)$, $i=1,\ldots,M$, and the complexity of $f_{i}$ is at most $2n\log_{2}(2n+2)$,$i=1,\ldots,M$. The complexity of $f_{M+1}$ is at most $2n\log_{2}(2n)$. Thus, the classical complexity of VGT.Dec is at most $M\log_{2}(2n)+2nM\log_{2}(2n+2)+2n\log_{2}(2n)=O(Mn\log_{2}n)$. The decryption procedure contains $M$ quantum measurements and $n$-qubit QOTP decryption, so its quantum complexity is $M+2n$. Then the complexity of VGT.Dec is $O(Mn\log_{2}n)$. Thus, the dependence of the complexity of VGT.Dec on the evaluated circuit $\mathcal{C}$ is $M$.    $\Box$

5 Conclusions and Discussions

In this article, encrypted gate $EG[U]$ is defined. Based on gate teleportation, a two-party computation scheme is proposed to implement $EG[U]$ or $EG[P^{x}]$. Then, we present a non-interactive way to remove the $P$-error which is generated during the homomorphic evaluation of $T/T^{\dagger}$-gate. In this way, we construct the detailed QHE scheme GT and a variation VGT. Both of them are perfectly secure, $\mathcal{F}$-homomorphic and quasi-compact. Moreover, the schemes GT and VGT are proved to have $M\log M$-quasi-compactness and $M$-quasi-compactness, respectively. We prove the $M$-quasi-compactness is the optimal.

The QHE schemes are constructed for unitary quantum circuit that contains no quantum measurement. If we add a key-updating rule for measurement, then our schemes would be usable for the quantum circuit with measurement. The key-updating rule for measurement has been introduced in Ref.[15].

Our QHE schemes allow the homomorphic evaluation of any unitary quantum circuit ($\mathcal{F}$-homomorphic), and have perfect security. However, they do not conflict with the no-go result given by Yu et al.[13], since they are not compact and do not satisfy the definition of QFHE. It should be emphasized that, it is valuable to study the quasi-compact QHE scheme which can implement any quantum circuit homomorphically. Using the $M$-quasi-compact QHE scheme VGT, the complexity of the decryption procedure is independent of the size of quantum circuit $\mathcal{C}$; The decryption procedure is efficient only if $\mathcal{C}$ contains polynomial number of $T/T^{\dagger}$-gates (e.g. $M=poly(n)$). Thus, our QHE schemes are suitable for homomorphic evaluation of any quantum circuit with low $T/T^{\dagger}$-gate complexity, such as any polynomial-size quantum circuit or any quantum circuit with polynomial number of $T/T^{\dagger}$-gates.

Based on these results, there are two possible directions in the future researches.

• •

Transform interactive quantum protocol into non-interactive one. This article has proposed a gate-teleportation-based two-party computation scheme, which can implement $EG[U]$. Actually, this scheme can be used to remotely perform $U$ gate. Because the quantum measurement in the scheme can be deferred until the final stage, the interaction can be eliminated, and then an interactive protocol can be transformed into a non-interactive one. This kind of transformation may be extended to transform many other interactive quantum protocols.

• •

Straightforward application of our QHE schemes. The efficiency of our QHE schemes depends on the total number of $T/T^{\dagger}$-gates. In order to implement application efficiently, the evaluated quantum circuit is required to have polynomial number of $T/T^{\dagger}$-gates. So it is important to optimize the number of $T/T^{\dagger}$-gates in the circuit while developing quantum application. In the future, we can also analyze the $T/T^{\dagger}$-complexity of some specific quantum algorithms (Quantum Fourier transformation (QFT) or Shor algorithm [27], HHL algorithm [28], etc), and study the homomorphic implementation of these fundamental quantum algorithms using our QHE schemes.

Appendix 0.A Some definitions about quantum homomorphic encryption

In this section, we introduce some concepts about QHE, including symmetric-key QHE, homomorphism, compactness, QFHE, quasi-compactness and security. Some definitions can be referred to Ref.[15].

Definition 1 (Symmetric-key quantum homomorphic encryption)

A symmetric-key QHE scheme QHE contains the following four algorithms

QHE=(QHE.KeyGen,QHE.Enc,QHE.Eval,QHE.Dec).

1.Key Generation.

$(sk,\rho_{e}vk)\leftarrow\texttt{QHE.KeyGen}(1^{n})$, where $sk$ is the secret key, $\rho_{evk}$ is quantum evaluation key in $D(\mathcal{H}_{evk})$. The evaluation key is optional in symmetric QHE scheme.

2.Encryption.

$\texttt{QHE.Enc}_{sk}:D(\mathcal{H}_{M})\rightarrow D(\mathcal{H}_{C})$, where $D(\mathcal{H}_{M})$ and $D(\mathcal{H}_{C})$ are the set of density operators in plaintext space and ciphertext space, respectively.

3.Evaluation.

$\texttt{QHE.Eval}^{QC}:D(\mathcal{H}_{evk}\otimes\mathcal{H}_{C})\rightarrow D(\mathcal{H}_{C^{\prime}}\otimes\mathcal{H}_{aux})$, where $\mathcal{H}_{C^{\prime}}$ is the result space of quantum computation on the space $\mathcal{H}_{C}$. For any quantum circuit $QC$ (called evaluated circuit), with induced channel $\Phi_{QC}:D(\mathcal{H}_{M})\rightarrow D(\mathcal{H}_{M^{\prime}})$, we define a channel $\texttt{Eval}^{QC}$ that maps $D(\mathcal{H}_{C})$ to $D(\mathcal{H}_{C^{\prime}})$ with an additional auxiliary quantum state in space $\mathcal{H}_{aux}$. The evaluation key in $D(\mathcal{H}_{evk})$ is used up in the process.

4.Decryption.

$\texttt{QHE.Dec}_{sk}:D(\mathcal{H}_{C^{\prime}}\otimes\mathcal{H}_{aux})\rightarrow D(\mathcal{H}_{M^{\prime}})$. For any possible secret key $sk$, $\texttt{Dec}_{sk}$ is a quantum channel that maps ciphertext state together with auxiliary state to a plaintext state in $D(\mathcal{H}_{M^{\prime}})$.

Definition 2 (Compactness)

QHE scheme QHE is compact if the algorithm QHE.Dec is independent of the evaluated circuit $QC$.

Definition 3 (Homomorphism)

Let $\mathcal{L}=\{\mathcal{L}_{\kappa}\}_{\kappa\in\mathds{N}}$ be a class of quantum circuits. A quantum encryption scheme QHE is homomorphic for the class $\mathcal{L}$ if for any sequence of circuits $\{C_{\kappa}\in\mathcal{L}_{\kappa}\}_{\kappa\in\mathds{N}}$ and input $\rho\in D(\mathcal{H}_{M})$, there exists a negligible function $negl$ such that:

[TABLE]

where $(sk,\rho_{evk})\leftarrow\texttt{QHE.KeyGen}(1^{\kappa})$ and $\Phi_{C_{\kappa}}$ is the channel induced by quantum circuit $C_{\kappa}$.

Definition 4 (Quantum fully homomorphic encryption)

A QHE scheme is a quantum fully homomorphic encryption scheme if

it is compact and 2. 2.

it is $\mathcal{F}$-homomorphic (or homomorphic for $\mathcal{F}$), where $\mathcal{F}$ is the set of all quantum circuits over the universal quantum gate set $\{X,Z,H,P,CNOT,T,T^{\dagger}\}$.

Definition 5 (Quasi-compactness)

Let $\mathcal{L}=\{L_{\kappa}\}_{\kappa\in\mathds{N}}$ be the set of all quantum circuits over the universal quantum gate set $\{X,Z,H,P,CNOT,T,T^{\dagger}\}$. Let $f:\mathcal{L}\rightarrow\mathds{R}_{\geq 0}$ be some function on the circuits in $\mathcal{L}$. A QHE scheme is $f$-quasi-compact if there exists a polynomial $p$ such that for any sequence of circuits $\{C_{\kappa}\in\mathcal{L}_{\kappa}\}_{\kappa\in\mathds{N}}$ with induced channels $\Phi_{C_{\kappa}}:D(\mathcal{H}_{M})\rightarrow D(\mathcal{H}_{(}M^{\prime}))$, the circuit complexity of decrypting the output of $\texttt{QHE.Eval}^{C_{\kappa}}$ is at most $f(C_{\kappa})p(\kappa)$.

Actually, QHE is a class of quantum encryption with special property. So its security can be defined following the definition of quantum encryption. Concretely, there are three level of security, e.g. computational security, information theoretic security and perfect security. This article focuses only on the QHE with perfect security. So we present the definition of perfect security as follows.

Definition 6 (perfect security)

QHE scheme QHE is perfectly secure if there exists a quantum state $\Omega^{\mathrm{A}^{\prime}}$ such that for all states $\rho^{\mathrm{AE}}$ we have that:

[TABLE]

where QHE.Enc is an encryption algorithm performed on the part $\mathrm{A}$ of quantum state $\rho^{\mathrm{AE}}$. Denote $\texttt{QHE.Enc}(\rho^{\mathrm{AE}})$ as a quantum ensemble over the probability distribution of the secret key and all the randomness in the quantum algorithm.

Appendix 0.B Elementary identities about quantum gates

For the quantum gates in the set $\mathcal{S}$, there exists the following identities (up to a global phase):

[TABLE]

In the description of quantum circuit, the standard measurement (or $Z$-basis measurement) is represented as the diagram in Fig.6(a). The $U$-rotated Bell measurement can be transformed into the standard measurement. Their relation is shown in Fig.6(b).

The $\mathrm{SWAP}$ can be implemented from three $\mathrm{CNOT}$ gates, e.g.

[TABLE]

In quantum circuit, $SWAP_{i,j}$ is represented as the diagram in Fig.7.

Appendix 0.C Key-updating rules

Suppose the evaluated quantum circuit consists of the gates in the set $\mathcal{S}=\{X,Z,H,P,CNOT,T,T^{\dagger}\}$. The quantum data has $n$ qubits and is encrypted according to QOTP scheme with the secret key being a $2n$-bit string. The secret key is the initial key of key-updating. Let the initial key be $(x_{0},z_{0})$, where $x_{0},z_{0}\in\{0,1\}^{n}$. Denote $x_{0}=x_{0}(1)x_{0}(2)\cdots x_{0}(n)$ and $z_{0}=z_{0}(1)z_{0}(2)\cdots z_{0}(n)$. Given $n$-qubit data, the $w$th ($w=1,\ldots,n$) qubit is encrypted with the $w$th pair of bits $(x_{0}(w),z_{0}(w))$. Once that a quantum gate is performed on the $w$th encrypted qubit, the $w$th pair of bits should be updated so as to decrypt that qubit correctly. Denote by $(x_{j},z_{j})$ the key after the $j$th key-updating, where $x_{j}=x_{j}(1)x_{j}(2)\cdots x_{j}(n)$,$z_{j}=z_{j}(1)z_{j}(2)\cdots z_{j}(n)$.

Rules 1:

If $Gate[j]$ does not act on the $w$th qubit, then let $(x_{j}(w),z_{j}(w)):=(x_{j-1}(w),z_{j-1}(w))$; Otherwise goto rules 2 and 3.

Rules 2:

If $Gate[j]=CNOT_{w,w^{\prime}}$, then let

[TABLE]

Rules 3:

If $Gate[j]$ acts only on the $w$th qubit, there exist the following cases.

1. 1.

If $Gate[j]=X_{w}$ or $Z_{w}$, then let $(x_{j}(w),z_{j}(w)):=(x_{j-1}(w),z_{j-1}(w))$. 2. 2.

If $Gate[j]=H_{w}$, then let $(x_{j}(w),z_{j}(w)):=(z_{j-1}(w),x_{j-1}(w))$. 3. 3.

If $Gate[j]=P_{w}$, then let $(x_{j}(w),z_{j}(w)):=(x_{j-1}(w),x_{j-1}(w)\oplus z_{j-1}(w))$. 4. 4.

If $Gate[j]\in\{T_{w},T_{w}^{\dagger}\}$, in our QHE schemes, $Gate[j]$ is executed with a subsequent operation $EG[P^{x_{j-1}(w)}]$. Denote by ($r_{x}(i)$, $r_{z}(i)$) the classical output of $EG[P^{x_{j-1}(w)}]$ (Assume $Gate[j]$ is the $i$th gate in the sequence of $T/T^{\dagger}$-gates). Let

[TABLE]

Based on these key-updating rules Rules 1,2,3, the keys $(x_{j},z_{j})$, $j=1,\ldots,N$ can be computed from the evaluated circuit and initial key $(x_{0},z_{0})$. It can be verified that, these keys satisfy the following relations.

If $Gate[j]$ does not act on $w$th qubit ($\forall j,w$), then

[TABLE] 2. 2.

If $Gate[j]\in\{X,Z,H,P\}$ acts on $w$th qubit, then (up to a global phase)

[TABLE] 3. 3.

If $Gate[j]$ is $CNOT_{w,w^{\prime}}$, then (up to a global phase)

[TABLE] 4. 4.

If $Gate[j]$ is $T_{w}/T_{w}^{\dagger}$ and is the $i$th gate in the sequence of $T/T^{\dagger}$-gates, then (up to a global phase)

[TABLE]

where $(r_{x}(i),r_{z}(i))$ is the classical output of $EG[P^{x_{j-1}(w)}]$.

Appendix 0.D An example for the scheme GT

Given any single-qubit unitary operator $U$ and any $\epsilon>0$, it is possible to approximate $U$ to within $\epsilon$ using a circuit composed of $H$ gates and $T$-gates. In order to verify the principle of our QHE scheme GT, we only consider the single-qubit circuit $C_{1}=HTHT$, which is composed of $T$ and $HTH$ (see Fig.8). Up to a global phase, the gates satisfy $T=R_{z}(\pi/4)$ and $HTH=R_{x}(\pi/4)$.

The quantum circuit $C_{1}$ is given $n=1$ qubit as input, and the $N=4$ quantum gates are performed on the single-qubit. $C_{1}$ can be described as a sequence of the gates, e.g $Gate[1]=T,Gate[2]=H,Gate[3]=T,Gate[4]=H$. It contains $M=2$ $T$-gates and $j_{1}=1,w_{1}=1,j_{2}=3,w_{2}=1$. The QHE scheme GT for $C_{1}$ uses $M=2$ Bell states denoted by $|\Phi_{00}\rangle_{c_{i},s_{i}},i=1,2$. The qubits labeled as $s_{i}$ and $c_{i}$ are held by Server and Client, respectively. Fig.9 shows the QHE scheme GT for $C_{1}$. Because $n=1$, the secret key is $sk=(x_{0},z_{0})$, where $x_{0}=x_{0}(1),z_{0}=z_{0}(1)$.

In the evaluation procedure, Server should finish the quantum operations shown in the dashed box. In addition, Server must generate $M+1=3$ key-updating functions $g_{1}$, $g_{2}$ and $f$ based on key-updating rules and evaluated circuit $C_{1}$. Key-updating functions $x_{0}(1)=g_{1}(x_{0},z_{0})$, $x_{2}(1)=g_{2}(x_{0},z_{0},r_{x}(1),r_{z}(1))$ are expressed as follows

[TABLE]

Key-updating function $(x_{4},z_{4})=f(x_{0},z_{0},r_{x}(1),r_{z}(1),r_{x}(2),r_{z}(2))$ is expressed as follow

[TABLE]

In the decryption procedure, Client performs two quantum measurements: (1) according to the function $g_{1}$, Client computes the measurement basis $\Phi(P^{x_{0}(1)})$, and then performs quantum measurement and obtains a pair of bits $(r_{x}(1),r_{z}(1))$; (2) according to the function $g_{2}$, Client computes the measurement basis $\Phi(P^{x_{2}(1)})$, and then performs quantum measurement and obtains a pair of bits $(r_{x}(2),r_{z}(2))$. Finally, according to the function $f$, Client computes the final key $(x_{4}(1),z_{4}(1))$ and performs QOTP decryption transformation.

Appendix 0.E An example for the scheme VGT

For two-qubit quantum computation, we choose two-qubit quantum Fourier transformation (QFT) as example. The two-qubit QFT can be implemented by the quantum circuit $C_{2}$ in Fig.10, which contains $H,CNOT,T,T^{\dagger}$.

The quantum circuit $C_{2}$ is given $n=2$ qubits, and output $2$ qubits. It consists of $N=7$ quantum gates, and can be described as a sequence of gates, e.g. $Gate[1]=H_{1}$, $Gate[2]=CNOT_{2,1}$, $Gate[3]=T_{1}^{\dagger}$, $Gate[4]=CNOT_{2,1}$, $Gate[5]=T_{1}$, $Gate[6]=T_{2}$, $Gate[7]=H_{2}$. The circuit contains $2$ $T$-gates and $1$ $T^{\dagger}$-gate. It can be known from $C_{2}$ that, $M=3$ and $j_{1}=3$, $w_{1}=1$, $j_{2}=5$, $w_{2}=1$, $j_{3}=6$, $w_{3}=2$. The QHE scheme VGT for $C_{2}$ should use $M=3$ Bell states denoted by $|\Phi_{00}\rangle_{c_{i},s_{i}}$,$i=1,2,3$. The qubits labeled as $s_{i}$ and $c_{i}$ are held by Server and Client, respectively. Fig.11 shows the QHE scheme VGT for $C_{2}$. Because $n=2$, the secret key is $sk=(x_{0},z_{0})$, where $x_{0}=x_{0}(1)x_{0}(2)$, $z_{0}=z_{0}(1)z_{0}(2)$.

In the evaluation procedure, Server should finish the quantum operations shown in the dashed box. In addition, Server must generate $2M+1=7$ key-updating functions $\{g_{i}\}_{i=1}^{3}$ and $\{f_{i}\}_{i=1}^{4}$ based on key-updating rules and evaluated circuit $C_{2}$. Key-updating functions $x_{2}(1)=g_{1}(x_{0},z_{0})$, $x_{4}(1)=g_{2}(x_{3},z_{3})$, $x_{5}(2)=g_{3}(x_{5},z_{5})$ are expressed as follows

[TABLE]

The three key-updating functions $(x_{3},z_{3})=f_{1}(x_{0},z_{0},r_{x}(1),r_{z}(1))$, $(x_{5},z_{5})=f_{2}(x_{3},z_{3},r_{x}(2),r_{z}(2))$, $(x_{6},z_{6})=f_{3}(x_{5},z_{5},r_{x}(3),r_{z}(3))$, $(x_{7},z_{7})=f_{4}(x_{6},z_{6})$ are expressed as follows

[TABLE]

In the decryption procedure, Client performs three rounds of the computations “$g_{i}$-measurement-$f_{i}$” and obtains the key $(x_{6},z_{6})$. In the $i$th round $(i=1,\ldots,3)$, Client alternately performs the following steps: (1)according to the function $g_{i}$, Client computes the measurement basis; (2)Client measures the pair of qubits $(s_{i},c_{i})$ and obtains two bits $(r_{x}(i),r_{z}(i))$; (3)according to the function $f_{i}$, Client computes the intermediate key $(x_{j_{i}},z_{j_{i}})$. Then, based on the function $f_{4}$, Client computes the final key $(x_{7},z_{7})$ from $(x_{6},z_{6})$. Finally, Client performs QOTP decryption with the key $(x_{7},z_{7})$.