Editing Prepare-and-Send Universal Blind Quantum Computation

The [https://arxiv.org/abs/0807.4154 example protocol] achieves the functionality of [[Secure Client- Server Delegated Quantum Computation]] by assigning quantum computation to an untrusted device while maintaining privacy of the input, output and computation of the client. The client requires to be able to prepare and send quantum states while the server requires to possess a device with quantum memory, measurement and entanglement generation technology. Following description deals with a method which involves quantum offline and classical online communication, called Blind Quantum Computation. It means the protocol needs one-time quantum communication at the end or starting of the protocol while continuous classical communication between the parties, throughout the execution. It comes with the properties of [[Secure Client- Server Delegated Quantum Computation#Properties|correctness]], [[Secure Client- Server Delegated Quantum Computation#Properties|blindness]] and [[Secure Client- Server Delegated Quantum Computation#Properties|universality]].
</br> </br>

'''Tags:'''  [[Category: Two Party Protocols]] [[:Category: Two Party Protocols|Two Party]], [[Category: Universal Task]][[:Category: Universal Task|Universal Task]], [[Category: Quantum Functionality]] [[:Category: Quantum Functionality|Quantum Functionality]], Quantum Offline communication, Classical Online communication, [[Supplementary Information#Measurement Based Quantum Computation|Measurement Based Quantum Computation (MBQC)]], [[Measurement-Only Universal Blind Quantum Computation|Measurement Only UBQC]], [[Pseudo-Secret Random Qubit Generator (PSQRG)]], [[Prepare-and-Send Verifiable Universal Blind Quantum Computation|Prepare and Send Verifiable Universal Blind Quantum Computation (VUBQC)]].

==Outline==
The following Universal Blind Quantum Computation (UBQC) protocol uses the unique feature of Measurement Based Quantum Computation [[Supplementary Information#Measurement Based Quantum Computation (MBQC)|(MBQC)]] that separates the classical and quantum parts of a computation. MBQC requires a set of initial entangled states, called graph states for computation. Here, we shall use a special family of graph states, [[Supplementary Information#Brickwork States|brickwork states]] which are universal (can implement any quantum operation) for X-Y measurements and do not leak any specific data about the computation during preparation. The protocol can be divided into three stages: preparation, computation and output correction.<br/>
Preparation stage includes a partially quantum Client preparing and sending quantum states to the Server who constructs the required brickwork state. Computation stage involves interaction. Output Correction involves retrieval of correct output from the results sent by the Server. We shall discuss below three protocols with different attributes but same functionality. All UBQC protocols discussed below require Client to prepare the required quantum states for computation and send those to the Server, hence the name ''Prepare and Send UBQC''. Protocol 1a deals with a partially quantum Client capable of preparing initial quantum states for the construction of brickwork state with classical input/output computation. Protocols 1b and 1c are extensions to accommodate quantum inputs and quantum outputs, respectively.

*	'''Client’s preparation''' Client sends the initial qubits for construction of brickwork state to Server in this step. Client has in her mind a quantum computation as a measurement pattern on the brickwork state. She prepares m x n single qubit states with randomly chosen local phase in order to hide her classical inputs later.
*	'''Server’s preparation''' Server prepares brickwork state of m rows and n columns. It entangles all the received qubits as per Client’s instructions. Thus, ends preparation stage.
*	'''Interaction and Measurement''' Client and Server interact to perform operations needed for computation. For a given computation and graph state, MBQC provides a measurement angle and some extra Pauli X, Z corrections, for each qubit. The correction sets (also called Dependency sets), unique for every graph state are based on previous measurement outcomes and can be obtained from '''[[Supplementary Information#Flow Construction-Determinism|flow construction]]'''. Also, as Client’s input state has random local phase, the same should be added to the measurement angle for computation along with Pauli Corrections to get the correct outcome. Now, in order to hide the output, Client randomly chooses to add a π rotation or not. The final measurement angle includes all the above parameters and hence, is sent to the Server. When Server returns the classical outcome, Client gets the correct outcome by taking into account the random π rotation and then uses it to calculate measurement angle for for the next qubit. The step is repeated until every qubit has been measured. Server returns measurement outcomes for the last column to Client. Client deciphers this outcome to get the final result. This ends the computation stage.

==Notations==
**<math>\phi</math>, measurement angle for given MBQC pattern to implement the required computation
**<math>\phi_0</math>, measurement angle including Pauli X,Z corrections
**<math>s_X,s_Z</math> Dependency sets for Pauli X and Pauli Z corrections, respectively (obtained from flow construction).
**<math>\theta</math>, randomly chosen angles by Client in order to hide classical input
** r <math>\epsilon_R\{0,1\}</math>, randomly chosen parameter for <math>\pi</math> rotation in order to hide classical output
**<math>\delta</math>, final measurement angle

==Requirements==
*'''Network Stage:''' [[:Category:Quantum Memory Network Stage|Quantum Memory]] [[Category:Quantum Memory Network Stage]]
*'''Required Network Parameters:''' 
**'''<math>\epsilon_j</math>''', which measures the error due to noisy operations.
**Number of communication rounds
**Circuit depth
**Number of physical qubits used
*Client should have preparation devices
*Quantum offline channel
*Classical online channel
*Server should be able to generate and store large network of entangled quantum states.

==Knowledge Graph==

{{graph}}

==Properties==
*(m,n) define dimensions of the brickwork state
*This protocol is secure/blind in every setting (universal)
*The Protocol needs Client to be able to prepare given initial quantum states
*The Protocols needs a quantum channel from Client to Server to transfer initial quantum states
*This protocol requires no quantum memory for the Client
*This protocol is universally composable [[Prepare-and-Send Universal Blind Quantum Computation#References|(1)]]
*[[Secure Client- Server Delegated Quantum Computation#Properties|Universality]] As brickwork states are universal for X-Y plane measurements, the protocol is universal. This protocol uses approximate universality although exact universality can be achieved if Client if allowed to communicate real numbers.
*[[Secure Client- Server Delegated Quantum Computation#Properties|Correctness]] If Client and Server follow the protocol as described above, the outcome will be correct.
*[[Secure Client- Server Delegated Quantum Computation#Properties|Blindness]] The protocol is blind while leaking at most (m,n) to the Server.

==Notations==
**<math>\phi</math>, measurement angle for given MBQC pattern to implement the required computation
**<math>\phi_0</math>, measurement angle including Pauli X,Z corrections
**<math>s_X,s_Z</math> Dependency sets for Pauli X and Pauli Z corrections, respectively (obtained from flow construction).
**<math>\theta</math>, randomly chosen angles by Client in order to hide classical input
** r <math>\epsilon_R\{0,1\}</math>, randomly chosen parameter for <math>\pi</math> rotation in order to hide classical output
**<math>\delta_x,y</math>, final measurement angle for the qubit at position (x,y) in the brickwork state

==Protocol Description==
[https://github.com/cgmcintyr/SimulaQron/tree/develop/examples/ubqc <u>click here for SimulaQron code</u>]
==='''Stage 1:''' Preparation===
*Input: Client: Dimensions of Brickwork State (m,n), Input States (<math>\psi_{0,y})</math>, Auxilliary Input States (<math>\psi_{x,y}</math>)
*Output: Server: Brickwork State <math>G_{\text{mxn}}</math>
**'''Client’s preparation''' 
##For each column x = 1,...,n
###For each row y = 1,...,m
#### Client prepares  and sends the qubits to Server.
**'''Server’s preparation'''
#Server creates an entangled state from all received qubits, according to their indices, by applying CTRL-Z gates between the qubits in order to create a brickwork state <math>G_{\text{n x m}}</math>.

==='''Stage 2:''' Computation Stage===
*Input: Client: Measurement Angle: <math>\delta_{x,y}</math>
*Output: Server: Measurement Outcome: <math>s_{x,y}</math>
**'''Interaction and measurement'''
#For each column x = 1,...,n 
##For each row y = 1,...,m
###Client computes <math>\phi '_{x,y}</math> where <math>s^X_{0,y}=s^Z_{0,y}=0</math> <br/>
###Client chooses <math>r_{x,y} \epsilon_R {0,1}</math> and computes <math>\delta_{x,y}=\phi '_{x,y}+\theta_{x,y}+\pi r_{x,y}</math>.
###Client transmits <math>\delta_{x,y}</math> to Server. Server measures in the basis <math>\{|+_{\delta_{x,y}}\rangle, |-_{\delta_{x,y}}\rangle\}</math>
###Server transmits the result <math>s_{x,y}\epsilon {0,1}</math> to Client.
###If <math>r_{x,y} = 1,</math> Client flips <math>s_{x,y}</math>; otherwise she does nothing.
**'''Output Correction [only for quantum outputs]'''
#Server sends to Client all qubits in the last layer.
#Client performs the final Pauli corrections .

==References==
#[https://arxiv.org/abs/1301.3662 Dunjko et al (2014)]

<div style='text-align: right;'>''*contributed by Shraddha Singh''</div>