Prepare-and-Send Verifiable Universal Blind Quantum Computation: Difference between revisions

Prepare-and-Send Verifiable Universal Blind Quantum Computation (edit)

Revision as of 17:32, 17 April 2019

6,720 bytes added , 17 April 2019

no edit summary

Shraddha

Write, autoreview, editor, reviewer

3,125

edits

@@ Line 20: / Line 20: @@
 ** For the server to create a cylinder brickwork state, the client prepares <math>m*n</math> single qubit states. The <math>n</math> qubit input states are specially encoded and all the other non-input qubits except the trap qubit are prepared with randomly chosen local phase angles.
 ** During this preparation, the client randomly selects one qubit as the trap qubit and corresponding to the graph of cylinder brickwork state, all the other qubits in the tape are set as the dummy qubits. The trap qubit is prepare with the local phase angle set to <math>0</math>.
-** The client then sends all the prepared qubits in the respective order so the graph state can be constructed by the server.
+** The client then sends all the prepared qubits in the respective order so the graph state can be constructed by the server. <br></br>
-* '''Server's Preparation'''
+* '''Server's Preparation''': The server receives the qubits in the order of <math>m</math> rows and <math>n</math> columns and entangles them according to the cylinder brickwork state (using CZ gate).<br></br>
-The server receives the qubits in the order of <math>m</math> rows and <math>n</math> columns and entangles them according to the cylinder brickwork state (using CZ gate).
+* '''Interaction and Measurement''': This step is exactly the same as for [[Prepare and Send-Universal Blind Quantum Computation]].
-* '''Interaction and Measurement'''
+** The client sends the measurement angle to the server for every single qubit. This measurement angle includes the parameters like correction sets obtained from flow construction, input state's random local phase and a <math>\pi</math> rotation to hide the output. Thus it reveals no information about the underlying computation.
-This step is exactly the same as for [[Prepare and Send-Universal Blind Quantum Computation]].
+** The server sends the classical output of each non-input qubit's measurement to the client. The client considers the <math>\pi</math> rotation to get the corrected output. The client also uses this to calculate the measurement angle and thus repeats the process until the last output qubits are reached.<br></br>
+* '''Verification''': The verification is carried on by the client by comparing the outcome of the trap qubit measurements with the expected outcome.
+'''Quantum outputs''':
+** The server sends all the output qubits to the client.
+** From these output qubits, the client performs a measurement on the trap qubit. If the output is equal to the expected outcome, the computation is verified. Otherwise, it is rejected.
+** If the computation is accepted, output correction is performed on the other output qubits (except the trap qubit).
+'''Classical outputs''':
+** The server continues performing measurements on the output qubits with the measurement angles sent by the server.
+** The client compares the output of the trap qubit with the expected output. If it is equal, computation is verified. Otherwise, it is rejected. If the computation is accepted, the client accepts the other output measurement results as the computation result.
+==Notation==
+* <math>n</math>: Total number of input qubits. Also total number of output qubits in quantum outputs.
+* <math>m</math>: Total number of qubits in the graph state.
+* <math>|I\rangle</math>: <math>n</math> qubit input state.
+* <math>|e\rangle</math>: Encoded <math>n</math> qubit input state.
+* <math>x</math>: Set of random bits used in encoding <math>|I\rangle</math> via quantum one time pad.
+* <math>t</math>: Trap qubit position vertex in the graph state.
+* <math>D</math>: Set of all position vertices in the tape of the cylinder brickwork state.
+* <math>\theta_i</math>: Random local phase angles for qubit <math>i</math>.
+* <math>|+\rangle_{\theta_i}</math>:  <math>\frac{1}{\sqrt{2}} (|0\rangle +e^{i\theta_i}|1\rangle)</math>
+* <math>\phi_i</math>: True measurement angle for qubit $i$.
+* <math>\phi^{'}_i</math>: Updated version of measurment angle for qubit <math>i</math>.
+* <math>r \in \{ 0, 1\}</math>: randomly chosen parameter for <math>\pi</math> rotation in order to hide classical output.
+* <math>\delta_i</math>: Final measurement angle for qubit <math>i</math>.
+* <math>b_i</math>: Measurement output by the server.
+* <math>s</math>: Sequence of length m describing the result of the nonoutput measurements. <math>s_i \in \{0, 1\}</math>
+==Hardware Requirements==
+* Quantum computation resources for the server.
+* A quantum channel from client to server to transfer initial quantum states.
+* Classical channel from client to server to tranfer measurement angles and outputs.
+* Measurement devices for the server and the client in case of quantum outputs.
+==Properties==
+* The client is partially quantum and should be able to prepare the given initial quantum states.
+* This protocol is secure against malicious adversary setting and also detects a cheating server.
+* This protocol is universal in nature. The universality of the cylinder brickwork state guarantees that server’s knowledge about the graph does not reveal anything about the underlying computation.
+* This protocol requires no quantum memory for the client.
+* This protocol is blind in nature, only revealing <math>n</math> and <math>m</math>.
+* This protocol is <math>1-\frac{1}{2m}</math> verifiable in quantum output case.
+* This protocol is <math>1-\frac{1}{m}</math> verifiable in classical output case.
+* The trap qubit in the tape format of the cylinder brickwork state remains disentangled from the rest of the graph.
+* Every qubit of the underlying graph could potentially be an isolated trap qubit.
+==Pseudo-Code==
+'''Protocol for quantum output case''': <br></br>
+'''Stage 1: '''Client's preparation:</br>
+'''Input''': Input quantum states, prepared non-input qubits, a trap qubit and dummy qubits.
+</br>
+'''Output''': The server receives all the quantum states in order of the labeling of the vertices of the graph state.
+* The client encodes and prepares the first <math>n</math>-input state.
+<div style="text-align: center;"><math>|e\rangle = X^{x1}_1 Z_1(\theta_1) \otimes ... \otimes X^{xn}_n Z_n(\theta_n)|I\rangle</math> </div>
+* Client randomly chooses the <math>t</math> to be the trap qubit, where <math>t \in D</math>.
+* For <math>i = n+1, n+2, ....m</math>:
+** if <math>i \in D</math>:
+*** if <math>i</math> == dummy qubit:
+**** State <math>|0\rangle</math> or <math>|1\rangle</math> is prepared
+*** if <math>i</math> == trap qubit:
+**** <math>|+\rangle_{\theta_i}</math> is prepared
+** if <math>i</math> == non-input qubit:
+*** <math>|+\rangle_{\theta_i}</math> is prepared
+* For <math>l = 1, 2, ...n</math>:
+** The client sends the qubits to the server.
+'''Stage 2: '''Server's preparation:</br>
+'''Output''': Cylinder brickwork state which has a disentangled trap qubit.
+* Server creates an entangled state from all received qubits using CZ operations according to their indices and creates the cylinder brickwork state.
+'''Stage 3: '''Interaction and Measurement:</br>
+'''Input''': <math>\delta_i</math></br>
+'''Output''': <math>b_i</math>
+* For <math>i = 1, 2, ... m-n</math>:
+** Client computes <math>\phi_i</math>.
+*** if <math>i == t</math>:
+**** \item <math>\phi_i = 0</math>
+** Client randomly selects <math>r_i</math>.
+** Client then computes the angle <math>\delta_i</math> and sends this to the server.
+<div style="text-align: center;"><math>\delta_i = \phi^{'}_i + \theta_i + r_i\pi</math></div>
+** Server measures <math>b_i</math> and sends it to client.
+** Client sets the value of <math>s_i</math> in <math>s</math> to be <math>b_i \oplus r_i</math>.
+'''Stage 4: '''Verification:</br>
+'''Input''': Output qubits <math>m-n+1</math> to <math>m</math></br>
+'''Output''': Verification result
+* For <math>i = m-n+1, ... m</math>:
+** Server sends output qubit <math>i</math> to client.
+* Client measures the output trap qubit <math>t</math> (which was disentangled) with angle <math>\delta_t = \phi_t + r_t\pi</math>.
+** Client obtains the result <math>b_t</math>.
+*** If <math>b_t == r_t</math>:
+**** Computation is accepted.
+*** else:
+**** Computation is rejected.
+==Further Information==
+<div style='text-align: right;'>''*contributed by Rhea Parekh''</div>