Editing Measurement-Only Verifiable Universal Blind Quantum Computation

The [https://arxiv.org/abs/1208.1495 example protocol] achieves the functionality of [[Secure Client- Server Delegated Computation|Delegated Computation]] which is the task of assigning quantum computation to an untrusted device while maintaining privacy of the computation. This protocol allows the client to verify the correctness of the blind delegated quantum computing with high probability. Here, the server prepares and sends a universal resource quantum state to the client, and the client only performs measurements to carry out the quantum computation. Using this method, it is easy to verify with high probability whether the server is honest. The computation here remains perfectly private from the server and this protocol can implement any quantum computation.

</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 Online communication, Classical Online communication, [[Supplementary Information#Measurement Based Quantum Computation|Measurement Based Quantum Computation (MBQC)]]

==Assumptions==
* The protocol assumes perfect state preparation, transmissions and measurements.
* There is no communication channel from the client to the server.
* The quantum channel from the server to the client should not be too lossy.

==Outline==

This protocol is based on MBQC and is mainly derived from Measurement-Only Universal Blind Quantum Computation. In this protocol, the server prepares and sends the resource state to the client, whereas the client performs measurements on the received states. The server is considered to be a general adversary and any computational deviations can be detected in this method by the client. 
<br></br>
By performing measurements, the client creates the final state to be a mixture of resource state and trap qubits, in a random distribution. If the measurement of all the trap qubits matches the expected outcome, then it shows with high probability that the server is honest and has not deviated from the protocol.  
<br></br>
This protocol is dived into two stages: Servers' preparation and Client's measurement.
* '''Server's preparation''': Server prepares the resource graph state required for MBQC by the Client. The server sends each qubit of this state to the Client, one by one. 
* '''Client's Measurement'''
** The client receives the qubits from the server and measures them in order to finally create an n-qubit state with the server, following the principle of MBQC. This n-qubit state comprises of randomly distributed resource state of measurement-based quantum computation and trap qubits. Based on [[no-signaling principle]], the server can never find out about the random distribution pattern. 
** On receiving the final n-qubit state, the client performs the measurement on these states with certain corrections. If the measurement of all the traps matches the expected outcome, the results are accepted otherwise the protocol is aborted.

==Notation==
* <math>G_{m\times n}</math>: Resource state
* <math>m\times n</math>: Resource state size
* <math>|\psi\rangle_P</math>: <math>P(|R\rangle\otimes |+\rangle^{\otimes \frac{N}{3}} \otimes |0\rangle^{\otimes \frac{N}{3}})</math>, this is the $n$-qubit state left with the server which contains the trap qubits (<math>|0\rangle</math>, <math>|+\rangle</math>) and resource state.
* <math>|R\rangle</math>: <math>\frac{n}{3}</math>-qubit resource state
* <math>P</math>: <math>n</math>-qubit permutation, which keeps the order of qubits in <math>|R\rangle</math>
*<math>|+\rangle</math>:  <math>\frac{1}{\sqrt{2}} (|0\rangle + |1\rangle)</math>
* q: <math>(x_1, ..., x_n, z_1, ..., z_n) \in \{0,1\}^{2n}</math>
* <math>\sigma_q</math>: <math>\bigotimes^n_{j=1}X^{x_j}_jZ^{z_j}_j</math>

==Requirements==
* Quantum computation resources for the server.
* A quantum channel from the server to the client to transfer the quantum states.
* Measurement device for the client.
* No channel is required from client to the server.

==Knowledge Graph==

{{graph}}

==Properties==
* This protocol is detects a cheating server with high probability.
* Universality: This protocol is universal in nature. The resource state used is universal and thus can implement any quantum computation.
* Correctness: The correctness of the protocol is implied form the measurement based quantum computing used.
* Blindness: As there exists no quantum channel from the client to the server, the no-signalling theorem ensures that no information about the states is sent to the server using just the measurements.
* The security of this protocol is device independent.

==Protocol Description==

'''Stage 1''': Server's preparation </br>
'''Input''': Dimensions of the resource state.
'''Output''': Client: receives all qubits
* Server creates <math>G_{m\times n}</math> and sends each qubit to Client

</br>
'''Stage 2''': Client's measurement</br>
'''Input''': Resource state qubits </br>
'''Output''': Final outcome
* For <math>i = 1, 2, ... m-1</math>:
** For <math>j = 1, 2, ...n</math>:
*** Client receives resource state qubit <math>|\psi\rangle_{i,j,0}</math> from server.
*** Client performs measurement on <math>|\psi\rangle_{i,j,0}</math> according to the measurement pattern.
** Through the measurements, Client creates the state <math>\sigma_q|\psi\rangle_P</math> in the server's possession, where
<div style="text-align: center;"><math> |\psi\rangle_P = P(|R\rangle\otimes |+\rangle^{\otimes \frac{N}{3}} \otimes |0\rangle^{\otimes \frac{N}{3}}) </math></div>

* For <math>i = 1, 2, ...n</math>: (for every qubit of <math>\sigma_q|\psi\rangle_P</math>)
** Client receives <math>\sigma_q{|\psi\rangle_P}_i</math> from the server.
** Measurement is done after applying the correction <math>\sigma^{\dagger}_q</math> on the qubit received.
** If result obtained is <math>|1\rangle</math> (for trap qubit <math>|0\rangle</math>) or <math>|-\rangle</math>(for trap qubit <math>|+\rangle</math>):
*** Protocol is aborted.
** else:
*** Protocol is continued and accepted if all trap qubits show expected outcome (<math>|0\rangle</math> or <math>|+\rangle</math>).

==Further Information==

A second protocol exists which uses the
property of the topological code, and does not use any
trap qubits. Here, after the <math>\sigma_q|\psi\rangle_P</math> state is prepared, client does topological measurement-based quantum computation with a correcting factor. If any error is detected, the protocol is aborted.

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