Prepare-and-Send Quantum Fully Homomorphic Encryption

The example protocol deals achieves the functionality of Secure Delegated Quantum Computation by a method which involves quantum offline and classical offline communication, called Quantum Fully Homomorphic Encryption (QFHE). It allows the Client to encrypt quantum data in such a way that Server can carry out any arbitrary quantum computations on the encrypted data without having to interact with the encrypting party. It hides the output and input of the computation while Server is allowed to choose the unitary operation for required computation. Thus, the circuit is known to the Server while efforts can be made to hide it from the encrypting party i.e. Client. Based on the existence of classical Homomorphic Encryption (HE) scheme, it comes with properties of correctness, i.e. for any arbitrary circuit if both the parties follow the protocol, the final outcome is deemed to be correct, compactness, i.e. decryption of data should be independent of the size of the quantum circuit used for computation and full homomorphism, i.e. it can perform any quantum computation. QFHE can be used to keep the circuit private to the Server and hidden from the Client unlike UBQC where the circuit is private to the Client and hidden from the Server.

Tags: Two Party,Universal Task, Quantum Functionality, Secure Delegated Quantum Computation, Quantum Offline Communication, Classical Offline Communication, Entanglement, Quantum Gadgets, Prepare and Send Verifiable Quantum Fully Homomorphic Encryption, Classical Fully Homomorphic Encryption for Quantum Circuits.

Assumptions

• This protocol is secure against malicious adversary setting
• One cannot decrypt the ciphertext without performing the Evaluation step
• A one-time quantum channel from Client to Server
• A one-time quantum channel from Server to Client
• The circuit has a polynomial number of T-Gates.

Outline

Homomorphic Encryption (HE) schemes can be divided into four stages: Key Generation generates keys for encryption, decryption, and evaluation of the circuit, Encryption encodes the input into a ciphertext using encryption key, Homomorphic Evaluation performs operations (implements the circuit) on the encrypted input using evaluation key and Decryption transforms result of the ciphertext to actual outcome of the circuit using decryption key. This protocol requires Client to prepare and send the quantum states to Server, hence the name, Prepare and Send QFHE. A QFHE scheme is fundamentally different from classical FHE in the aspect that an evaluation key is allowed to be a quantum state in the former case. Also, in the last step decryption for FHE is carried out subsystem by subsystem. This cannot be correct for QFHE as quantum states can be entangled, hence decryption should be carried out on the system as a whole. The QFHE version of encryption is based on quantum one-time pad (QOTP) i.e. randomly applying a Pauli Gate (X, Y, Z, I) in order to hide the input. A Fully Homomorphic Encryption can implement Universal Gates (a set of gates which can implement any quantum circuit). Most of the gates in this set work well with QOTP while for T gates one needs an additional gadget, in order to implement any arbitrary circuit and make the scheme Fully Homomorphic. This adds an additional step called ”Gadget Construction” during Key Generation Stage in this protocol

Key Generation 

This step generates homomorphic key sets consisting of the classical public key for encryption, a classical private key for decryption and a quantum evaluation key for operation on the encrypted input state. If the circuit involves L T gates, Client needs L+1 such key sets for L gadgets and one input state. The Client uses the classical HE Key Generation (HE.KeyGen) to get classical key sets. She stores all the public keys and secret keys in two separate sets (tuples). Quantum evaluation keys consist of the classical evaluation keys and L gadgets. Once constructed, the gadget is also encrypted using all public keys except the first one by the Client. As construction of gadgets takes secret keys (first L) as inputs, the public key used for its encryption should not belong to the same homomorphic key set used to construct the gadget. A classical description of the gadget, useful for evaluation is also encrypted and included in the gadget. Construction and encryption of gadgets is described in the last step.

• Gadget Construction This step involves the construction of gadgets to correct any additional phase gate error on the input due to T gates in the circuit. If there are L T gates in the Circuit, one needs L Gadgets constructed using L private keys and then encrypted using L public keys. The public key used for encryption should not belong to the same homomorphic key set of the private key used for construction. A gadget consists of 2m EPR pairs (maximally entangled qubits). The client starts with 4m such pairs. Performs pairwise Bell measurement on one-half of the EPR pairs. Pairs for Bell measurement are chosen according to the private decryption key used for the particular gadget. This leaves the other half of the EPR pairs entangled in the same pairs as chosen by Client to perform bell measurement. E.g. if (a,b) and (c,d) denote two EPR pairs and one performs bell measurement on a and c, then b and d become maximally entangled with some extra Pauli X, Z corrections due to measurement (refer to a one-pad key in supplementary draft). These corrections are determined by Client’s measurement outcomes. The resulting gadget thus has 2m EPR pairs, some of which have an inverse phase gate. Classical information of a gadget includes private key used, Client’s measurement outcomes and locations of inverse phase gates. This data is encrypted with the public key. Hence, L such gadgets consisting of encrypted classical information and 2m EPR pairs quantum one-time padded by the Pauli X, Z gates, are sent to the server.
  

Finally, Client stores all the gadgets with the classical evaluation key of the corresponding secret key (generated from HE.KeyGen) used to construct the gadget, as the set of quantum evaluation keys. Note that, the gadgets are quantum states and classical evaluation keys are random numbers, the resulting quantum evaluation key is what we call a classical-quantum (CQ) state.

Encryption

This step is used to encrypt the quantum input into a quantum ciphertext using the first public key which has not been used for gadget construction. Every input qubit state is quantum one time padded by the Client, using two classical random bits, one of which decided the operation of Pauli-X and the other operation of Pauli-Z gate on the qubit state. She also encrypts the classical random bits (called pad key) with the same public key using classical HE (HE.Enc) and hence stores it with the corresponding encrypted qubit state as a classical-quantum state. She then sends this CQ state, encrypted pad key, public key tuple, and evaluation key tuple to Server.

 Circuit Evaluation

This step operates the circuit on the encrypted input state and updates the encrypted classical information using the evaluation key. As stated earlier, any circuit can be implemented using a set of Universal Gates. This set consists of Clifford Gates and T gates. The Clifford group gates may affect a single qubit or multiple qubits but they follow a simple set of rules for updation of the encrypted classical information (pad key), given in the pseudocode. The server operates the circuit and with each gate in the circuit, it updates the encrypted classical description.
On the other hand, T gates affect only single qubits but one needs to make use of the gadgets constructed during key generation. The issue with T gates is that it adds an additional Phase gate (P) depending on the classical random bit used for QOTP in the previous step. As P gates do not commute like Pauli-X and Pauli-Z, so they need to be corrected before applying the next gate by the Server. This would reveal the pad key used for QOTP to the Server. Hence, to avoid this, the Client constructed gadgets, which apply an Inverse Phase operator or Identity on a qubit after every T-Gate, depending on the encrypted bit without leaking any information about the pad key. Thus, after applying a T gate on a qubit, P error is removed using a gadget as follows. Out of 2m EPR pairs, some qubits are measured pairwise including the input qubit with/without error and excluding one qubit entangled with one of the measured qubits. Input qubit is thus, transferred to this last unmeasured qubit, according to one-bit teleportation. Following are the steps to get the correct output qubit.

• Generate Measurement (QFHE.GenMeasurement()) The encrypted one pad key bit which determines phase gate error and the classical information of the gadget is used to determine a measurement order. Private key tells which qubits are entangled, thus, using the location of inverse phase gates, the qubits needed to be measured are decided. If one-pad key bit indicates a phase error then the measurement order of qubits includes an EPR pair with a phase gate else not.
• Gadget Correction (QFHE.Measurement()) Server performs the required measurements. The last unmeasured qubit is corrected input qubit. The qubit is one time padded with pad key determined by Client’s measurement outcomes, encrypted with the public key used for the gadget and Server’s measurement outcomes. Hence, it is still hidden from the Server.
  
• Recryption (QFHE.Rec()) Server recrypts pad key of the qubit with the same public key that encrypts the corrected output state i.e. the one used for the corresponding gadget. Then, he updates the encrypted pad key according to the T Gate (similar to what is done for the Clifford Gate), Client’s encrypted measurement outcomes and Server’s (his) measurement outcomes.

The server performs all the Clifford and T gates in the circuit following the respective procedure given above. Finally, he is left with the one time padded quantum output of the computation together with the required classical pad key encrypted with the public key of the gadget used for the last T gate, Lth public key. The server sends both the quantum state and classical encryptions to the Client.

Decryption 

The Client uses skL, which was not used to create any gadget (Gadgets used 0-(L-1) secret keys only) and decrypts sent encryptions to obtain the pad key. The pad key thus obtained determines the Pauli operations on the sent quantum state to obtain the final and correct outcome of the computation. The client performs the required operations on individual qubits of the quantum state and gets the output of his computation.

Notations

• $\mathrm {k}$, security parameter
• $\mathrm {L}$, number of T gates in the evaluation circuit
• $\mathrm {n}$, dimension of input qubit
• $\mathrm {pk_{i},sk_{i},evk_{i}}$, $\mathrm {i_{th}}$ homomorphic key set generated from HE.KeyGen(). Public key for encryption, secret key for decryption, evaluation function key, respectively for given k, the security parameter.
• $\Gamma _{pk_{i+1}}(\mathrm {sk_{i}} )$, Gadget using $\mathrm {i_{t}h}$ secret key ($sk_{i}$) and encrypted by $\mathrm {(i+1)_{th}}$ public key ($\mathrm {pk_{i+1}}$)
• $\sigma$, single qubit state
• Failed to parse (SVG (MathML can be enabled via browser plugin): Invalid response ("Math extension cannot connect to Restbase.") from server "https://wikimedia.org/api/rest_v1/":): {\displaystyle \rho=\ket{\psi}\bra{\psi}} , here $\rho$ is the density matrix of quantum state |ψi
• ρ, n-qubit input state, where n is determined by the Client
• ρ(HE.Encpk(a)), a is encrypted with public key pk and is represented by density matrix ρ
• p, location of inverse phase gate
• x,z measurement outcome sets of Client for her Bell Pair measurements.
• x’,z’ measurement outcome sets of Server for his Gadget measurement.
• x˜[i], resulting ciphertext one gets for an input ith element of array x or ith bit of key x after the Encrypting it with ith of public key string, pk.

Properties

Security Claim/ Theorems

• Indistinguishability under Chosen Plaintext Attacks by an adversary with quantum computational powers(q-IND-CPA). If FHE is q-IND-CPA secure then this protocol is q-IND-CPA secure. It means that an adversary cannot distinguish between ciphertext from a message and a ciphertext from an arbitrary quantum state such as |0ih0|
• Correctness. This protocol is perfectly correct such that,
  

Pr[QFHE.Decsk(QFHE.EvalevkC (HE.Encpk(x))) 6= C(x)] ≤ η(k)
, where ηk is a negligible function. This means that if the protocol is followed it results in the same output as when the circuit is operated on the input states directly with overwhelming probability.

• Compactness. If HE is compact then this protocol is compact. The complexity of applying QFHE.Dec on the results of QFHE.Eval is at most p(k), where p(k) is a polynomial dependent only on the security parameter k. This implies that decryption is independent of the size of the quantum circuit for evaluation.
• Circuit Privacy. This protocol is not circuit private as it does not guarantee that the client cannot gain information about the circuit evaluated i.e. the circuit is not private to one party and unknown to another. It can make the circuit private to the evaluator (Server) and hidden from the Client apart from the necessary leakage the output states gives if one uses circuit private HE for the protocol.

• Full Homomorphism. This scheme is fully homomorphic for circuits with polynomial sized T gates

Pseudo-Code

Stage 1 Client’s Preparation

Key Generation (QFHE.KeyGen(1k,1L))

• Input: No. of T gates (L), Security Parameter (k),
• Output: L+1 evaluation keys (encrypted Gadgets, classical HE evaluation key), L+1 public keys, L+1 secret keys

1. For i = 0 to L
   1. Client executes (pki,ski,evki) ← HE.KeyGen(1κ) to obtain L + 1 independent classical homomorphic key sets.
2. She sets the public key to be the tuple ( .
3. She sets the secret key to be the tuple ( .
4. For i = 0 to L − 1
   1. Client runs the procedure QFHE.GenGadgetpki+1(ski) to create the gadget Γpki+1(ski).
5. Client sets the evaluation key to be the set of all gadgets created in the previous step (including their encrypted classical information), plus the tuple ( . The resulting evaluation key is the classical-quantum (CQ) state {missing math}

Encryption(QFHE.Enc())

• Input: Quantum Input state density matrix (ρ) (say composed of n single qubit states, σ)
• Output: Encrypted pad keys: {a˜[0]...a˜[n], ˜b[i]...˜b[n]}; QOTP state: Xa[1]Zb[1]⊗.....⊗Xa[n]Zb[n]ρZb[1]Xa[1]⊗ ..... ⊗ Xa[n]Zb[n]

1. For i=1 to n
   1. Client chooses pad keys a,b
   2. She quantum one time pads the single qubit by applying XaZb on the single qubit state. XaZbσZbXa ← σ
   3. She encrypts the pad keys using one bit for each of a and b from the public key string pk0 using HE.Enc. (˜ )=(HE.Enc ),HE.Enc
   4. She apprehends encrypted pad keys to the one time padded quantum state to obtain CQ state,
2. Client sends encryptions (˜a[i],˜b[i]) and the quantum one time padded (QOTP) state Xa[1]Zb[1] ⊗ ..... ⊗ Xa[n]Zb[n]ρZb[1]Xa[1] ⊗ ..... ⊗ Xa[n]Zb[n], for all i to the Server with the evaluation keys and public keys.

Gadget Construction (QFHE.GenGadgetpki+1(ski))

1. Generate 4m EPR pairs (
2. Choose 2m pairs using sk
   1. If (sk = 0) then {(a1,a2),(a2,a3),...,(a4m−1,a4m)} ii. If (sk = 1) then {(a1,a3),(a2,a4),...,(a4m−2,a4m)}
3. For j=1 to 2m,
   1. Choose p[j]
   2. Perform Bell Measurement on jth pair with an extra (P†)p operation, get outcomes (x[j],z[j])
   3. Thus, new EPR pairs are{missing math}
      If (sk = 0) then {(b1,b2),(b2,b3),...,(b4m−1,b4m)}
      If (sk = 1) then {(b1,b3),(b2,b4),...,(b4m−2,b4m)}
      Denote the 2m entangled pairs be denoted by {(s1,t1),(s2,t2),...,(s2m,t2m)}, such that
      
      1. The classical information of gadget be g(sk)= ({(s1,t1),(s2,t2),...,(s2m,t2m),p,sk}.
         
      2. The quantum state of gadget can be written as {missing math}
4. Encrypt (x[j],z[j]), p[j] for all j and sk using pki+1. Resulting Gadget is the classical-quantum (CQ) state,{missing math}

Stage 2 Server’s Computation

Circuit Evaluation (QFHE.Eval())

• Input: public key tuple ( , Evaluation key tuple, Encrypted Pad key ({a˜[0]...a˜[n], ˜b[i]...˜b[n]}), QOTP Input State (Xa[1]Zb[1] ⊗ ..... ⊗ Xa[n]Zb[n]ρZb[1]Xa[1] ⊗ ..... ⊗ Xa[n]Zb[n])
• Output: QOTP Circuit Output State (Xa0[1]Zb0[1]⊗.....⊗Xa0[k]Zb0[k]ρ0Zb0[1]Xa0[1]⊗.....⊗Xa0[k]Zb0[k]), Corresponding Encrypted Pad key (a˜0,b˜0)=(HE.EvalCevkL(a˜),HE.EvalCevkL(˜b))

Let the Circuit be denoted by C and the gates be ci

1. For all i, ci gate is applied on qubit m and the mth bits of pad key (˜a[m],˜b[m]) are updated to

(a˜0[m],˜b0[m]) as follows.

1. 1. If ci = {P,H,CNOT}, a Clifford gate then (ciXa[m]Zb[m]ψ = Xa0[m]Zb0[m]ciψ)
      1. if ci =H then{missing math} (Hadamard tranforms X gate into Z and Z into X)
      2. if ci =P then
         {missing math}
      3. if ci =CNOT with m as target bit and n as control bit then (CNOT)
         (a˜[m],˜b[m];˜a[n],˜b[n]) → (a˜[m],˜b[m] ⊕˜b[n];˜a[m] ⊕a˜[n],˜b[n])
   2. If ci = Tj gate then (TjXa[m]Zb[m]ψ = Pa[m]Xa[m]Zb[m]Tjψ)
      1. Generate Measurement
         M← QFHE.GenMeasurement(˜a[m],Γpkj+1(skj),evkj)
         
      2. Gadget Correction
         (Xa0[m]Zb0[m]Tj)ψ ← QFHE.Measurement(M, Pa[m]Xa[m]Zb[m]Tjψ);
         Server gets measurement outcome x’,z’
      3. Recryption Server recrypts one-pad key using pkk+1
         QFHE.Recpkk+1(a˜[m],˜b[m]).
         
   3. Server updates the recrypted key using x,z and x’,z’.
   4. Server sends the updated encryption and QOTP output state to Client.

Stage 3 Client’s Correction

Decryption (QFHE.Dec())

• Input: QOTP Circuit Output State (Xa0[1]Zb0[1] ⊗ ..... ⊗ Xa0[k]Zb0[k]ρ0Zb0[1]Xa0[1] ⊗ ..... ⊗Xa0[k]Zb0[k]), Corresponding Encrypted Pad key (a˜0,b˜0)
• Output: Final outcome of the computation CρC† = ρ0 (a) Client uses skL to restore the pad key from sent encryption. (a0[i],b0[i])=(HE.Dec [i](a0[i]),HE.Dec [i](b0[i]))

1. Client uses skL to restore the pad key from sen encryption
2. Client uses pad key and operates Xa Zb on single qubits i separately just like encryption.
   Let single qubit representation of the output state be Xa0[i]Zb0[i]σ0Zb0[i]Xa0[i], then operation of Pauli X,Z gates as above yields σ0
3. Client repeats this for all single qubits and hence gets the quantum state ρ0, final outcome of the computation.

Further Information

*contributed by Shraddha Singh