Quantum Protocol Zoo - User contributions [en]

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T07:10:45Z

Harold:

The protocol allows a sender <math>S</math> to transmit an arbitrary quantum state <math>|\psi\rangle</math> to a receiver <math>R</math> in an anonymous way and uses the <math>N</math>-partite <math>W</math> state as a quantum resource.

==Assumptions==

The protocol relies on a set of classical subroutines (collision detection, receiver notification, veto and logical OR). Their proposed implementation [[Anonymous transmission in a noisy quantum network using the W state#References|[1]]] has been shown to be information-theoretically secure in the classical regime, even with an arbitrary number of corrupted participants, assuming the parties share pairwise authenticated private channels and a broadcast channel.

The protocol assumes that the implementations listed above remain secure even in the presence of a quantum adversary.

==Outline==

The <math>N</math> nodes first ensure that a single one is willing to send information. They go on with notifying the receiver of its role. They use a trusted source of <math>W</math> states to share entanglement between the <math>N</math> nodes. This is done via a measurement performed by all nodes except the sender and receiver. Entanglement is only established probabilistically, but when it is successful, it can be used to teleport an arbitrary quantum state chosen by <math>S</math>. The classical communication for teleporting the state is performed anonymously.

==Notation==




==Properties==

The protocol is sender and receiver secure in the semi-active scenario.
It is able to retain its security in the presence of noise affecting the <math>W</math> state distribution under the assumption that each qubit experiences the same noise map.

==Protocol Description==


; Collision detection
: Nodes run the classical collision detection protocol [9] to determine a single sender <math>S</math>. All nodes input 1 if they do wish to be the sender and 0 otherwise. If a single node wants to be the sender, continue.
; Receiver notification
: Nodes run the classical receiver notification protocol [9], where the receiver <math>R</math> is notified of her role.
; State distribution
: A trusted source distributes the <math>N</math>-partite <math>W</math> state.
; Measurement
: All nodes except for <math>S</math> and <math>R</math> measure in the {|0〉,|1〉} basis.
; Anonymous announcement of outcomes
: Nodes use the classical veto protocol [9] which outputs 0 if all the <math>N-2</math> measurement outcomes are 0, and 1 otherwise. If the output is 0 then anonymous entanglement is established, else abort.
; Teleportation
: Sender <math>S</math> teleports the message state |ψ〉 to the receiver <math>R</math>. Classical messagemassociated with teleportationis sent anonymously. The communication is carried outusing the classical logical OR protocol [9] which computes <math>m \oplus rand</math>, where <math>rand</math> is a random 2-bit string input by the receiver <math>R</math>.

==Simulation and benchmark==
A simulation code for benchmarking the Snonymous transmission protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/AnonymousTransmission here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==


==References==
#A. Broadbent and A. Tapp, inAdvances in Cryptology– ASIACRYPT 2007, edited by K. Kurosawa (Springer Berlin Heidelberg, Berlin, Heidelberg, 2007) pp. 410–426.

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T07:10:23Z

Harold: /* Knowledge Graph */

The protocol allows a sender <math>S</math> to transmit an arbitrary quantum state <math>|\psi\rangle</math> to a receiver <math>R</math> in an anonymous way and uses the <math>N</math>-partite <math>W</math> state as a quantum resource.

==Assumptions==

The protocol relies on a set of classical subroutines (collision detection, receiver notification, veto and logical OR). Their proposed implementation [[Anonymous transmission in a noisy quantum network using the W state#References|[1]]] has been shown to be information-theoretically secure in the classical regime, even with an arbitrary number of corrupted participants, assuming the parties share pairwise authenticated private channels and a broadcast channel.

The protocol assumes that the implementations listed above remain secure even in the presence of a quantum adversary.

==Outline==

The <math>N</math> nodes first ensure that a single one is willing to send information. They go on with notifying the receiver of its role. They use a trusted source of <math>W</math> states to share entanglement between the <math>N</math> nodes. This is done via a measurement performed by all nodes except the sender and receiver. Entanglement is only established probabilistically, but when it is successful, it can be used to teleport an arbitrary quantum state chosen by <math>S</math>. The classical communication for teleporting the state is performed anonymously.

==Notation==



{{graph}} -->

==Properties==

The protocol is sender and receiver secure in the semi-active scenario.
It is able to retain its security in the presence of noise affecting the <math>W</math> state distribution under the assumption that each qubit experiences the same noise map.

==Protocol Description==


; Collision detection
: Nodes run the classical collision detection protocol [9] to determine a single sender <math>S</math>. All nodes input 1 if they do wish to be the sender and 0 otherwise. If a single node wants to be the sender, continue.
; Receiver notification
: Nodes run the classical receiver notification protocol [9], where the receiver <math>R</math> is notified of her role.
; State distribution
: A trusted source distributes the <math>N</math>-partite <math>W</math> state.
; Measurement
: All nodes except for <math>S</math> and <math>R</math> measure in the {|0〉,|1〉} basis.
; Anonymous announcement of outcomes
: Nodes use the classical veto protocol [9] which outputs 0 if all the <math>N-2</math> measurement outcomes are 0, and 1 otherwise. If the output is 0 then anonymous entanglement is established, else abort.
; Teleportation
: Sender <math>S</math> teleports the message state |ψ〉 to the receiver <math>R</math>. Classical messagemassociated with teleportationis sent anonymously. The communication is carried outusing the classical logical OR protocol [9] which computes <math>m \oplus rand</math>, where <math>rand</math> is a random 2-bit string input by the receiver <math>R</math>.

==Simulation and benchmark==
A simulation code for benchmarking the Snonymous transmission protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/AnonymousTransmission here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==


==References==
#A. Broadbent and A. Tapp, inAdvances in Cryptology– ASIACRYPT 2007, edited by K. Kurosawa (Springer Berlin Heidelberg, Berlin, Heidelberg, 2007) pp. 410–426.

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T07:09:58Z

Harold:

The protocol allows a sender <math>S</math> to transmit an arbitrary quantum state <math>|\psi\rangle</math> to a receiver <math>R</math> in an anonymous way and uses the <math>N</math>-partite <math>W</math> state as a quantum resource.

==Assumptions==

The protocol relies on a set of classical subroutines (collision detection, receiver notification, veto and logical OR). Their proposed implementation [[Anonymous transmission in a noisy quantum network using the W state#References|[1]]] has been shown to be information-theoretically secure in the classical regime, even with an arbitrary number of corrupted participants, assuming the parties share pairwise authenticated private channels and a broadcast channel.

The protocol assumes that the implementations listed above remain secure even in the presence of a quantum adversary.

==Outline==

The <math>N</math> nodes first ensure that a single one is willing to send information. They go on with notifying the receiver of its role. They use a trusted source of <math>W</math> states to share entanglement between the <math>N</math> nodes. This is done via a measurement performed by all nodes except the sender and receiver. Entanglement is only established probabilistically, but when it is successful, it can be used to teleport an arbitrary quantum state chosen by <math>S</math>. The classical communication for teleporting the state is performed anonymously.

==Notation==


==Knowledge Graph==

{{graph}}

==Properties==

The protocol is sender and receiver secure in the semi-active scenario.
It is able to retain its security in the presence of noise affecting the <math>W</math> state distribution under the assumption that each qubit experiences the same noise map.

==Protocol Description==


; Collision detection
: Nodes run the classical collision detection protocol [9] to determine a single sender <math>S</math>. All nodes input 1 if they do wish to be the sender and 0 otherwise. If a single node wants to be the sender, continue.
; Receiver notification
: Nodes run the classical receiver notification protocol [9], where the receiver <math>R</math> is notified of her role.
; State distribution
: A trusted source distributes the <math>N</math>-partite <math>W</math> state.
; Measurement
: All nodes except for <math>S</math> and <math>R</math> measure in the {|0〉,|1〉} basis.
; Anonymous announcement of outcomes
: Nodes use the classical veto protocol [9] which outputs 0 if all the <math>N-2</math> measurement outcomes are 0, and 1 otherwise. If the output is 0 then anonymous entanglement is established, else abort.
; Teleportation
: Sender <math>S</math> teleports the message state |ψ〉 to the receiver <math>R</math>. Classical messagemassociated with teleportationis sent anonymously. The communication is carried outusing the classical logical OR protocol [9] which computes <math>m \oplus rand</math>, where <math>rand</math> is a random 2-bit string input by the receiver <math>R</math>.

==Simulation and benchmark==
A simulation code for benchmarking the Snonymous transmission protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/AnonymousTransmission here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==


==References==
#A. Broadbent and A. Tapp, inAdvances in Cryptology– ASIACRYPT 2007, edited by K. Kurosawa (Springer Berlin Heidelberg, Berlin, Heidelberg, 2007) pp. 410–426.

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T07:07:57Z

Harold: /* Properties */

The protocol allows a sender <math>S</math> to transmit an arbitrary quantum state <math>|\psi\rangle</math> to a receiver <math>R</math> in an anonymous way and uses the <math>N</math>-partite <math>W</math> state as a quantum resource.

==Assumptions==

The protocol relies on a set of classical subroutines (collision detection, receiver notification, veto and logical OR). Their proposed implementation [[Anonymous transmission in a noisy quantum network using the W state#References|[1]]] has been shown to be information-theoretically secure in the classical regime, even with an arbitrary number of corrupted participants, assuming the parties share pairwise authenticated private channels and a broadcast channel.

The protocol assumes that the implementations listed above remain secure even in the presence of a quantum adversary.

==Outline==

The <math>N</math> nodes first ensure that a single one is willing to send information. They go on with notifying the receiver of its role. They use a trusted source of <math>W</math> states to share entanglement between the <math>N</math> nodes. This is done via a measurement performed by all nodes except the sender and receiver. Entanglement is only established probabilistically, but when it is successful, it can be used to teleport an arbitrary quantum state chosen by <math>S</math>. The classical communication for teleporting the state is performed anonymously.

==Notation==


==Knowledge Graph==

{{graph}}

==Properties==

The protocol is sender and receiver secure in the semi-active scenario.
It is able to retain its security in the presence of noise affecting the <math>W</math> state distribution under the assumption that each qubit experiences the same noise map.

==Protocol Description==


; Collision detection
: Nodes run the classical collision detection protocol [9] to determine a single sender <math>S</math>. All nodes input 1 if they do wish to be the sender and 0 otherwise. If a single node wants to be the sender, continue.
; Receiver notification
: Nodes run the classical receiver notification protocol [9], where the receiver <math>R</math> is notified of her role.
; State distribution
: A trusted source distributes the <math>N</math>-partite <math>W</math> state.
; Measurement
: All nodes except for <math>S</math> and <math>R</math> measure in the {|0〉,|1〉} basis.
; Anonymous announcement of outcomes
: Nodes use the classical veto protocol [9] which outputs 0 if all the <math>N-2</math> measurement outcomes are 0, and 1 otherwise. If the output is 0 then anonymous entanglement is established, else abort.
; Teleportation
: Sender <math>S</math> teleports the message state |ψ〉 to the receiver <math>R</math>. Classical messagemassociated with teleportationis sent anonymously. The communication is carried outusing the classical logical OR protocol [9] which computes <math>m \oplus rand</math>, where <math>rand</math> is a random 2-bit string input by the receiver <math>R</math>.

==Further Information==


==References==
#A. Broadbent and A. Tapp, inAdvances in Cryptology– ASIACRYPT 2007, edited by K. Kurosawa (Springer Berlin Heidelberg, Berlin, Heidelberg, 2007) pp. 410–426.

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T07:05:02Z

Harold: /* Protocol Description */

The protocol allows a sender <math>S</math> to transmit an arbitrary quantum state <math>|\psi\rangle</math> to a receiver <math>R</math> in an anonymous way and uses the <math>N</math>-partite <math>W</math> state as a quantum resource.

==Assumptions==

The protocol relies on a set of classical subroutines (collision detection, receiver notification, veto and logical OR). Their proposed implementation [[Anonymous transmission in a noisy quantum network using the W state#References|[1]]] has been shown to be information-theoretically secure in the classical regime, even with an arbitrary number of corrupted participants, assuming the parties share pairwise authenticated private channels and a broadcast channel.

The protocol assumes that the implementations listed above remain secure even in the presence of a quantum adversary.

==Outline==

The <math>N</math> nodes first ensure that a single one is willing to send information. They go on with notifying the receiver of its role. They use a trusted source of <math>W</math> states to share entanglement between the <math>N</math> nodes. This is done via a measurement performed by all nodes except the sender and receiver. Entanglement is only established probabilistically, but when it is successful, it can be used to teleport an arbitrary quantum state chosen by <math>S</math>. The classical communication for teleporting the state is performed anonymously.

==Notation==


==Knowledge Graph==

{{graph}}

==Properties==


==Protocol Description==


; Collision detection
: Nodes run the classical collision detection protocol [9] to determine a single sender <math>S</math>. All nodes input 1 if they do wish to be the sender and 0 otherwise. If a single node wants to be the sender, continue.
; Receiver notification
: Nodes run the classical receiver notification protocol [9], where the receiver <math>R</math> is notified of her role.
; State distribution
: A trusted source distributes the <math>N</math>-partite <math>W</math> state.
; Measurement
: All nodes except for <math>S</math> and <math>R</math> measure in the {|0〉,|1〉} basis.
; Anonymous announcement of outcomes
: Nodes use the classical veto protocol [9] which outputs 0 if all the <math>N-2</math> measurement outcomes are 0, and 1 otherwise. If the output is 0 then anonymous entanglement is established, else abort.
; Teleportation
: Sender <math>S</math> teleports the message state |ψ〉 to the receiver <math>R</math>. Classical messagemassociated with teleportationis sent anonymously. The communication is carried outusing the classical logical OR protocol [9] which computes <math>m \oplus rand</math>, where <math>rand</math> is a random 2-bit string input by the receiver <math>R</math>.

==Further Information==


==References==
#A. Broadbent and A. Tapp, inAdvances in Cryptology– ASIACRYPT 2007, edited by K. Kurosawa (Springer Berlin Heidelberg, Berlin, Heidelberg, 2007) pp. 410–426.

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T06:32:37Z

Harold: /* Outline */

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T06:24:27Z

Harold:

Anonymous transmission in a noisy quantum network using the W state

2021-11-12T06:22:08Z

Harold: Created page with "   The protocol allows a..."

Prepare-and-Send Verifiable Universal Blind Quantum Computation

2021-11-12T06:07:33Z

Harold:

The [https://arxiv.org/abs/1203.5217 example protocol] achieves the functionality of [[Secure Verifiable Client-Server Delegated Quantum Computation|Secure Verifiable Delegated Quantum Computation]] which enables a client with limited quantum technology to delegate a computation to an untrusted but powerful quantum server in such a manner, where the privacy of the computation is maintained. This protocol introduces verifiability as a property and allows the client to verify the correctness of [[Prepare-and-Send Universal Blind Quantum Computation]]. The client has an ability to verify whether the server has followed the instructions of the protocol and also can check if the server tried to deviate from the protocol which would have resulted in an incorrect output state.

'''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 Universal Blind Quantum Computation]].

==Assumptions==
* The protocol assumes perfect state preparation, transmissions, and measurements.
* The client never deviates from the protocol.
* The position of the trap qubit always remains hidden from the server.

==Outline==
This protocol is a modified version of [[Prepare-and-Send Universal Blind Quantum Computation]], which is based on [[Supplementary Information#Measurement Based Quantum Computation (MBQC)|(MBQC)]]. Here a powerful adversarial server is delegated with quantum computation which maintains the privacy of the computation. Any computational deviations by this server are detected by high probability. This is achieved by insertion of randomly prepared and blindly isolated single qubits in the computation, which act as a trap (trap qubits), hence assisting the client in verification.

MBQC required a set of the initial state for computation. The [[Glossary#Brickwork States|brickwork states]] used in [[Prepare-and-Send Universal Blind Quantum Computation]] are modified to [[Glossary#Cylinder Brickwork States|cylinder brickwork states]] which enables the client to embed a trap qubit surrounded by multiple dummy qubits without disrupting the computation. This state is universal and maintains the privacy of the client's preparation. The dummy qubits here do not take part in the actual computation as they are disentangled from the rest of the qubits of the graph state. Hence by adding them to the neighboring nodes of the trap qubits, they are blindly isolated and thus do not interfere with the actual computation. The dummy qubits are added next to the trap qubit in a tape format as seen in [[Glossary#Cylinder Brickwork States|cylinder brickwork states]].

This protocol is divided into four stages: Client's preparation, server's preparation, interaction and measurement, verification.

* '''Client's preparation''': The partially quantum client prepares the quantum states with embedded traps qubits and sends them to the server for creation of the cylinder brickwork state.
** For the server to create a cylinder brickwork state, the client prepares <math>m</math> single qubit states. The first <math>n</math> qubit input states are specially encoded and [[Supplementary Information#Quantum One Time Pad|Quantum one time pad]] is applied to these states with randomly chosen keys.
** Then 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 prepared with the local phase angle set to <math>0</math>. The dummy qubits isolate the trap qubit from the graph state.
** The remaining non-input qubit states (not including the dummy states and trap qubit) are prepared with randomly chosen local phase angles.
** The client then sends all the prepared qubits in the respective order to the server so the graph state can be constructed.

* '''Server's Preparation''': The server receives the qubits in a sequential order of rows and columns till all <math>m</math> qubits are received. The server then 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]].
** For a specific computation, MBQC decides which measurement angle is selected along with some extra Pauli X, Z corrections for every qubit. The correction sets are unique for every graph state and depend on the previous measurement. These can obtained from '''[[Supplementary Information#Flow Construction-Determinism|flow construction]]'''. The qubits have a randomly chosen local phase angle and hence the same local phase angle is used for computation as well as for output correction. To hide the state, a randomly chosen <math>\pi</math> rotation which may or may not be added. From all the above-mentioned conditions, a final measurement angle is formed and the client sends a classical message to the server to inform the server about the final measurement basis (in (X, Y) plane) in which they should measure the corresponding qubit. Thus it reveals no information about the underlying 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 for the next qubit and thus repeats the process until the last output qubits are reached.

* '''Verification''': The verification is carried on by the client by comparing the outcome of the trap qubit measurements with the expected outcome.
**'''For 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).
**'''For 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 <math>i</math>. This is assigned corresponding to the graph state.
* <math>r \in \{ 0, 1\}</math>: randomly chosen parameter for <math>\pi</math> rotation in order to hide classical output.
* <math>N_g(k)</math>: Denotes neighborhood of vertex k in graph state
* <math>f</math>: Function which defines flow from measured qubits to noninput qubits, <math>f:</math> output vertices <math>\xrightarrow{}</math> input vertices
* <math>\theta^{'}_i</math>: Updated version of Random local phase angle for qubit <math>i</math>.
* <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>

==Requirements==
* Quantum computation resources for the server.
* A quantum channel from the client to the server to transfer initial quantum states.
* Classical channel from the client to the server to transfer measurement angles and outputs.
* Measurement devices for the server.
* Measurement devices for the client in case of quantum outputs.

==Knowledge Graph==

{{graph}}

==Properties==
* The client is partially quantum and should be able to prepare the given initial quantum states.
* Security: This protocol is secure against malicious adversary setting and also detects a cheating server.
* Universality: This protocol is universal in nature. The universality of the cylinder brickwork state guarantees that the server’s knowledge about the graph does not reveal anything about the underlying computation.
* Correctness If Client and Server follow the protocol as described above, the outcome will be correct.
* Blindness: This protocol is blind in nature, only revealing <math>n</math> and <math>m</math>.
* This protocol requires no quantum memory for the client.
* 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.

==Protocol Description==

'''Protocol for quantum output case''': 
'''Stage 1: '''Client's preparation:

'''Input''': Cylindrical brickwork state, <math>|I\rangle</math>.

'''Output''': Server: <math>m</math> qubits sequentially.

* The client prepares <math>|e\rangle = X^{x1}_1 Z_1(\theta_1) \otimes ... \otimes X^{xn}_n Z_n(\theta_n)|I\rangle</math> using QOTP.
* Client randomly chooses <math>t</math>, where <math>t \in D</math>.
* For <math>i = n+1, n+2, ....m</math> (non-input qubits):
** if <math>i \in D</math>:
*** if <math>i != t</math> then state <math>|0\rangle</math> or <math>|1\rangle</math> is prepared
*** if <math>i == t</math> then <math>|+\rangle_{\theta_i}</math> is prepared
** else <math>|+\rangle_{\theta_i}</math> is prepared
* <math>\forall l\epsilon\{1,..,n\}</math>, Client sends all qubits to server.

'''Stage 2: '''Server's preparation:
'''Input''': <math>m</math> qubits sequentially.
'''Output''': entangled graph state with 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:
'''Input''': <math>\delta_i</math>
'''Output''': <math>s_i</math>

* For <math>i = 1, 2, ... m-n</math> (received qubits):
** Client computes <math>\phi_i</math>.
*** if <math>i == t</math>, then <math>\phi_i = 0</math>
** Client randomly selects <math>r_i</math> and generates <math>\theta'_i = \theta_i + r_i</math>.
** Client then computes the angle <math>\delta_i = (-1)^{x_i + s_{f^{-1}(i)}}\phi_i + \sum_{j:i \in N_g(f(j)}\theta'_i + s_i\pi</math> and sends <math>\delta_i</math> to server.
** Server measures <math>i</math> and sends <math>b_i</math> to client.
** Client sets the value <math>s_i = b_i \oplus r_i</math> in <math>s</math>

'''Stage 4: '''Verification:
'''Input''': Output qubits <math>m-n+1</math> to <math>m</math>
'''Output''': Verification result
* For <math>i = m-n+1, ... m</math> (output qubits):
** Server sends <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>, then computation is accepted.
*** else, computation is rejected.

==Simulation and benchmark==
A simulation code for benchmarking the Quantum Token Protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/VBQC here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

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

Quantum Teleportation

2021-11-12T06:02:26Z

Harold:

This [https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.70.1895 example protocol] performs the task of [[(Quantum) Teleportation]] by which a quantum state (or information stored in a quantum state) can be transmitted physically from one location (or one party) to another. This protocol requires sharing an [[entangled state]] like an [[EPR pair]] between two parties and also allowing the parties to communicate classically (sending bits of information). Quantum teleportation can be treated as a send/receive scheme for qubits. Quantum teleportation provides a mechanism of sending an unknown qubit from one location to another, without physically moving the particle. This task can be done due to the existence of long-range correlations between entangled pairs. The quantum teleportation is used widely as a basic protocol in many other quantum communication and quantum cryptography protocols.

'''Tags:''' [[:Category: Building Blocks|Building Blocks]], teleportation, quantum communication, sending quantum information, send/receive in the quantum network, [[:Category: Quantum Functionality|Quantum Functionality]], [[:Category: Specific Task|Specific Task]]
[[Category: Quantum Functionality]] [[Category: Building Blocks]] [[Category: Specific Task]]

==Assumptions==
* The protocol is deterministic i.e. the entangled state and the measurements and gates are assumed perfect, the protocol will always succeed.
* During the protocol, value of <math>\alpha</math> and <math>\beta</math> will remain unknown to both the parties (and any adversary as well).
* A public classical channel is assumed between the two parties.
* There is no transfer of matter or energy involved. Sender's particle has not been physically moved to receiver; only the particle's state has been transferred.

==Outline==

The quantum teleportation protocol begins with a quantum state or qubit, in the possession of the first party (the sender). We need this quantum state to be transferred to the second party (the receiver). This state is unknown to both parties meaning that the sender does not know the representation of the qubit on any basis. Before starting the protocol the two parties must share an entangled state (for example an [[EPR pair]]). The entangled state here is a two-qubit state where each party has one share of these qubits which have a special [[quantum correlation]]. After sharing the entangled state, the parties can take an arbitrary distance (In theory, without any noise and by assuming that the entanglement can be held for an arbitrary distance which is not the case in the real experiments). After this preparation stage, the two parties will perform the protocol as follows:
* At sender's location, a Bell measurement of the EPR pair qubit and the qubit to be teleported is performed, yielding one of four measurement outcomes, which can be encoded in two classical bits of information. Both qubits at the sender's location are then discarded.
* Using the classical channel, the two bits are sent from the sender to the receiver.
* As a result of the measurement performed at the sender's location, the EPR pair qubit at the receiver's location is in one of four possible states. Of these four possible states, one is identical to the original quantum state, and the other three are closely related. Which of these four possibilities actually obtained, is encoded in the two classical bits. Knowing this, the EPR pair qubit at the receiver's location is modified by local unitary operations that the receiver performs on his state. And the result will be the original qubit.

==Knowledge Graph==

{{graph}}

==Notation==

* <math>|\psi\rangle_O:</math> The unknown original state to be teleported from the sender to the receiver.
* <math>|\Phi^+\rangle_{AB}:</math> The EPR pair (or Bell state) shared between two parties.
* Bell States(<math>|\Phi^+\rangle</math>, <math>|\Phi^-\rangle</math>, <math>|\Psi^+\rangle</math> and <math>|\Psi^-\rangle</math>): Set of orthonormal two-qubit states having the maximum amount of entanglement. These states can be used as a basis for a two-qubit quantum system.
* <math>I:</math> The identity operator.
*<math>X,Y,Z:</math> The [[Pauli Operators]].

==Properties==
* This protocol uses a public classical channel to transfer two bits of classical information.
* The teleportation protocol uses entanglement (or entangled EPR states) as a resource.
* The teleportation protocol is secure against cloning attacks, as a result of [[no-cloning theorem]] in quantum mechanics i.e. any of the involved states in the protocol cannot perfectly be copied. Also, any other interference will affect the shared state between the two parties and the attack will be discovered.
* The teleportation protocol is secure against entanglement attacks because of the [[monogamy of entanglement]] in quantum mechanics. It means that if an adversary tries to entangle her state with the shared EPR pair, the amount of the entanglement of the shared state between two parties will change and the attacker will be discovered.
* The size of the classical information sent by the sender to the receiver is infinitely smaller than the information required to give a classical description of the teleported quantum state.

==Protocol Description==

[https://github.com/quantumprotocolzoo/protocols/tree/master/QuantumStateTeleportation click here for Python code]

[https://github.com/apassenger/CQC-Python/tree/master/examples/pythonLib/teleport/Quantum%20State%20Teleportation click here for SimulaQron code]

*'''Input:''' The qubit <math>|\psi\rangle</math> is the to-be-sent state which the first party (the sender) wants to transfer to the second party (the receiver). The quantum state can be written generally in standard basis as:
<math>|\psi\rangle = \alpha |0\rangle_{O} + \beta |1\rangle_{O}</math>, <math>\alpha</math> and <math>\beta</math> coefficients are unknown to the sender.
'''Stage 1''' Share entangled qubits (EPR pair)
# Generate an EPR pair (or a maximally-entangled two-qubit sate) and give one qubit to the sender (A) and one to the receiver (B). The shared EPR state between the two parties is described as:
<math>|\Phi^+\rangle_{AB} = \frac{1}{\sqrt{2}} (|0\rangle_A|0\rangle_B + |1\rangle_A|1\rangle_B)</math>
#This step is a pre-preparation step which should be run before the protocol starts. The state of all the three particles are as follows:
<math>|\psi\rangle_O \otimes |\Phi^+\rangle_{AB} = (\alpha|0\rangle_O + \beta|1\rangle_O) \otimes \frac{1}{\sqrt{2}} (|0\rangle_A|0\rangle_B + |1\rangle_A|1\rangle_B)</math>
In order to make the next step more clear, the above three-qubit states can be written in [[Bell basis]] (spaned by four two-qubit Bell states <math>|\Phi^+\rangle</math>, <math>|\Phi^-\rangle</math>, <math>|\Psi^+\rangle</math> and <math>|\Psi^-\rangle</math>)
<math>|\psi\rangle_O \otimes |\Phi^+\rangle_{AB} = \frac{1}{2} [|\Phi^+\rangle_{AO} \otimes (\alpha |0\rangle + \beta |1\rangle)_B + |\Phi^-\rangle_{AO} \otimes (\alpha |0\rangle - \beta |1\rangle)_B + |\Psi^+\rangle_{AO} \otimes (\beta |0\rangle + \alpha |1\rangle)_B + |\Psi^-\rangle_{AO} \otimes (\beta |0\rangle - \alpha |1\rangle)_B]</math>
'''Stage 2''' Local Measurement by the sender(A)
* '''Input:''' <math>|\psi\rangle_O \otimes |\Phi^+\rangle_{AB}</math>
* '''Output:''' The output of the sender's measurement in Bell basis

# The sender(A) performs a local measurement on two qubits that she has (the original state and her share of the EPR pair) in the Bell basis.
# The output of this measurement will be one of the four Bell states: <math>|\Phi^+\rangle</math>, <math>|\Phi^-\rangle</math>, <math>|\Psi^+\rangle</math> and <math>|\Psi^-\rangle</math>

'''Stage 3''' Send classical information
# According to the result of the measurement on the previous step, the sender A sends two bits of classical information to B indicating the result of her measurement:
## '''if''' the result is <math>|\Phi^+\rangle \rightarrow</math> send <math>00</math>
##'''if''' the result is <math>|\Phi^-\rangle \rightarrow</math> send <math>01</math>
## '''if''' the result is <math>|\Psi^+\rangle \rightarrow</math> send <math>10</math>
## '''if''' the result is <math>|\Psi^-\rangle \rightarrow</math> send <math>11</math>

'''Stage 4''' Local Operation by the receiver(B)
*'''Input:''' two classical bits: c <math>\in \{00, 01, 10, 11\}</math>
*'''Output:''' Teleported state <math>|\psi\rangle</math>
# The receiver performs a local unitary operation on his qubit. Before this step and after that the two-qubit measurement is performed by the sender, The state of the receiver will change to the following states according to the sender's measurement results:
# '''if''' the result is <math>|\Phi^+\rangle \rightarrow</math>, receiver's state will be: <math>\alpha |0\rangle + \beta |1\rangle</math>
# '''if''' the result is <math>|\Phi^-\rangle \rightarrow</math>, receiver's state will be: <math>\alpha |0\rangle - \beta |1\rangle</math>
# '''if''' the result is <math>|\Psi^+\rangle \rightarrow</math>, receiver's state will be: <math>\beta |0\rangle + \alpha |1\rangle</math>
# '''if''' the result is <math>|\Psi^-\rangle \rightarrow</math>, receiver's state will be: <math>\beta |0\rangle - \alpha |1\rangle</math>
* The receiver will perform following operators on the above states:
# '''if''' he receives <math>00 \rightarrow</math>, he performs <math>I</math> (does nothing)
# '''if''' he receives <math>01 \rightarrow</math>, he performs <math>Z</math> ([[Pauli Z]])
# '''if''' he receives <math>10 \rightarrow</math>, he performs <math>X</math> ([[Pauli X]])
# '''if''' he receives <math>11 \rightarrow</math>, he performs <math>ZX</math> (Pauli X then a Pauli Z)
*As a result, the state of the receiver will be: <math>|\psi\rangle_B = \alpha|0\rangle + \beta |1\rangle</math>

==Simulation and benchmark==
A simulation code for benchmarking the Quantum Teleportation Protocol is available [[fn:5] https://github.com/LiaoChinTe/netsquid-simulation/tree/main/QuantumTeleportation here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==

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

Quantum Token

2021-11-12T05:58:20Z

Harold:

Money is issued by one party (bank) to a prover (client) such that when he presents it to a verifier
(merchant), he/she is satisfied that the money presented by client comes from the bank. It comes
with the property of [[unforgeability]] and [[transferability]]. Unforgeability means that there should exist
no method to produce an identical copy by anyone but the bank, and transferability allows that this
money can be used by the verifier as a client himself in the next round.

'''Tags:''' [[:Category: Multi Party Protocols|Multi Party Protocols]], non local games, [[:Category: Quantum Enhanced Classical Functionality|Quantum Enhanced Classical Functionality]], [[:Category: Specific Task|Specific Task]]
[[Category: Prepare and Measure Network Stage]]
[[Category: Specific Tasks]]
[[Category: Quantum Enhanced Classical Functionality]]
[[Category: Multi Party Protocols]]

==Assumptions==
* Money is physically transferred to the holders
* If <math>F^{cv}_{tol} > (1+1/\sqrt{2})/2</math>, a dishonest user is exponentially unlikely to be authenticated by two independent verifiers (success in cheating to use the same ticket for two independent verifiers by measuring in intermediate basis between the two bases, asked by the verifiers individually).

==Outline==
The protocol can be divided into three parts
* '''Preparation''' Bank prepares few rows of qubit-pairs chosen from two different non-orthogonal sets of basis. Each pair has at least one state from both bases, such that the qubit pair states are non-orthogonal. It associates each such chosen set with a serial number and shares the classical information about the choices for respective serial number with trusted merchants.
* '''Interaction''' This step involves challenge questions by the verifier to prove that he has a valid token, by playing a part of a [[non-local game]]. In this game, the merchant asks the client to measure in one of the two bases in from which the qubit pairs were chosen. As each qubit pair contains at least one state from each basis chosen, after the measurement one of the qubits (encoded in the basis chosen by the merchant) would give the correct result.
* '''Transaction''' The merchant compares this qubit outcome whose encoding basis matches with merchant's basis for the game. The merchant accepts the ticket if the ratio of the number of valid outcomes to the total number of qubits measured is more than or equal to a certain threshold fidelity value.

==Notation==
*<math>N=n*r*2</math>, total number of qubits
*<math>F^{cv}_{tol}:</math> is the tolerance fidelity set by the verifiers
*<math>F^{cv}_{tol}(r*2) < F^{exp}:</math> where <math> F^{exp}</math> is the average experimental fidelity

==Requirements==
*Network stage: [[:Category: Quantum Memory Network Stage|quantum memory network]][[Category:Quantum Memory Network Stage]].

==Knowledge Graph==

{{graph}}

==Properties==
* Challenge questions reveal no information about the token
* No quantum communication is needed
* Tokens are remotely verifiable/ classically verifiable
* A dishonest user is exponentially unlikely to succeed with probability at most, <math>p_d = e^{ND}(2F^{cv}_{tol}-1||2/3)</math>, where <math>(2F^{cv}_{tol}-1)</math> is the fraction of qubits to be copied in order to forge a ticket and 2/3 is the average fidelity of copies produced by optimal cloning map, D being relative entropy.
* An honest user is exponentially likely to succeed with probability at least, <math>p^{cv}_h = e^{ND}(F^{exp}||F^{cv}_{tol})</math>

==Protocol Description==
'''Input:''' Bank (<math>\text{n*r}</math> qubit pairs), where, qubit-pairs <math>\epsilon_R\{(0,+),(0,-),(1,+),(1,-),(+,0),(-,0),(+,1),(-,1)\}</math> 
'''Output:''' (Merchant) accept or reject
'''Stage 1''' Preparation 
# Bank prepares Token<math>_S</math> with <math>n*r</math> qubit pairs
# Bank distributes tickets to clients
# Bank distributes the classical record of states corresponding to S to trusted verifiers (merchants).

'''Stage 2''' Interaction 
# Merchant asks client to measure a few qubit-pairs(say, a row) in a randomly chosen basis M <math> \epsilon_R \{X,Z\}</math>
# Client returns measurement outcome (m) for all qubit pairs asked to measure
'''Stage 3''' Transaction 
# Merchant compares the number of qubit pairs with the valid outcome for the qubit which was generated in M basis as k.
# Merchant accepts if <math>k/(r*2)>F^{cv}_{tol}</math> else he rejects

==Simulation and benchmark==
A simulation code for benchmarking the Quantum Token Protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/QToken here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==

# [https://arxiv.org/abs/1705.01428 BOTZKD-QMoney (2018)] replaces qubits with [[coherent states]] and it implements the quantum money on the fly (i.e. without quantum memory).

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

BB84 Quantum Key Distribution

2021-11-12T05:57:12Z

Harold: /* Simulation and benchmark */

This [https://core.ac.uk/download/pdf/82447194.pdf example protocol] implements the task of [[Quantum Key Distribution]] (QKD). The protocol enables two parties to establish a classical secret key by preparing and measuring qubits. The output of the protocol is a classical secret key which is completely unknown to any third party, namely an eavesdropper.

'''Tags:''' [[:Category:Two Party Protocols|Two Party]], [[:Category:Quantum Enhanced Classical Functionality|Quantum Enhanced Classical Functionality]], [[:Category:Specific Task|Specific Task]],[[Quantum Key Distribution]], [[Device Independent Quantum Key Distribution|Device Independent QKD]], [[Category:Multi Party Protocols]] [[Category:Quantum Enhanced Classical Functionality]][[Category:Specific Task]][[Category:Prepare and Measure Network Stage]]
==Assumptions==
* '''Network:''' we assume the existence of an authenticated public classical channel between Alice and Bob.
* '''Timing:''' we assume that the network is synchronous.
* '''Adversarial model:''' [[coherent attacks]].

==Outline==
The protocol shares a classical key between two parties, Alice and Bob.
The BB84 quantum key distribution protocol consists of the following steps:
*'''Distribution:''' This step involves preparation, exchange and measurement of quantum states. For each round of the distribution phase, Alice randomly chooses a basis (a pair of orthogonal states) out of two available bases (X and Z). She then randomly chooses one of the two states and prepares the corresponding quantum state in the chosen basis. She sends the prepared state to Bob. Upon receiving the state, Bob announces that he received the state and randomly chooses to measure in the either of the two available bases (X or Z). The outcomes of the measurements give Bob a string of classical bits. The two parties repeat the above procedure <math>n</math> times so that at the end of the distribution phase each of them holds an <math>n</math>-bit string.
*'''Sifting:''' Alice and Bob publicly announce their choices of basis and compare them. They discard the rounds in which Bob measured in a different basis than the one prepared by Alice.
*'''Parameter estimation:''' Alice and Bob use a fraction of the remaining rounds (in which both measured in the same basis) in order to estimate the [[quantum bit error rate]] (QBER).
*'''Error correction:''' Alice and Bob choose a classical error correcting code and publicly communicate in order to correct their string of bits. At the end of this phase Alice and Bob hold the same bit-string.
*'''Privacy amplification:''' Alice and Bob use an [[extractor]] on the previously established string to generate a smaller but completely secret string of bits, which is the final key.

==Requirements ==
*'''Network Stage:''' [[:Category:Prepare and Measure Network Stage|Prepare and Measure]]
*'''Relevant Network Parameters:''' transmission error <math>\epsilon_T</math>, measurement error <math>\epsilon_M</math> (see [[:Category:Prepare and Measure Network Stage|Prepare and Measure]])
*'''Benchmark values:'''
**Minimum number of rounds ranging from <math>\mathcal{O}(10^2)</math> to <math>\mathcal{O}(10^5)</math> depending on the network parameters <math>\epsilon_T,\epsilon_M</math>, for commonly used security parameters.
**<math>QBER \leq 0.11</math>, taking a depolarizing model as benchmark. Parameters satisfying <math> \epsilon_T+\epsilon_M\leq 0.11</math> are sufficient to asymptotically get positive secret key rate.
*requires [[random number generator]].

==Knowledge Graph==

{{graph}}

==Notation==
*<math>n</math> number of total rounds of the protocol.
*<math>\ell</math> size of the secret key.
*<math>X_i, Y_i</math> bits of input of Alice and Bob, respectively, that define the measurement basis.
*<math>A_i,B_i</math> bits of output of Alice and Bob, respectively.
*<math>Z_1^n</math> is a shorthand notation for the string <math>Z_1,\ldots, Z_n</math>.
*<math>K_A,K_B</math> final key of Alice and Bob, respectively.
*<math>Q_X</math> is the quantum bit error rate QBER in the <math>X</math> basis.
*<math>Q_Z</math> is the quantum bit error rate QBER in the <math>Z</math> basis estimated prior to the protocol.
*<math>H</math> is the Hadamard gate. <math>H^{0} = I, H^{1} = H</math>.
*<math>\gamma</math> is the probability that Alice (Bob) prepares (measures) a qubit in the <math>X</math> basis.
*<math>\epsilon_{\rm EC}</math>, <math>\epsilon'_{\rm EC}</math> are the error probabilities of the error correction protocol.
*<math>\epsilon_{\rm PA}</math> is the error probability of the privacy amplification protocol.
*<math>\epsilon_{\rm PE}</math> is the error probability of the parameter estimation.

==Properties==
The protocol implements <math>(n,\epsilon_{\rm corr},\epsilon_{\rm sec},\ell)</math>-QKD, which means that it generates an <math>\epsilon_{\rm corr}</math>-correct, <math>\epsilon_{\rm sec}</math>-secret key of length <math>\ell</math> in <math>n</math> rounds. The security parameters of this protocol are given by
<math>\epsilon_{\rm corr}=\epsilon_{\rm EC},\
\epsilon_{\rm sec}= \epsilon_{\rm PA}+\epsilon_{\rm PE},</math>
and the amount of key <math>\ell</math> that is generated is given by
<math> \begin{align}
\ell \geq & (1-\gamma)^2n (1-h(Q_X+\nu) -h(Q_Z)) \\ &-\sqrt{(1-\gamma)^2n}\big(4\log(2\sqrt{2}+1)(\sqrt{\log\frac{2}{\epsilon_{\rm PE}^2}}+ \sqrt{\log \frac{8}{{\epsilon'}_{\rm EC}^2}})) \\& -\log(\frac{8}{{\epsilon'}_{\rm EC}^2}+\frac{2}{2-\epsilon'_{\rm EC}})-\log (\frac{1}{\epsilon_{\rm EC}})- 2\log(\frac{1}{2\epsilon_{\rm PA}})
\end{align}
</math>
where <math>\nu = \sqrt{ \frac{(1+\gamma^2n)((1-\gamma)^2+\gamma^2)}{(1-\gamma)^2\gamma^4n^2}\log(\frac{1}{\epsilon_{\rm PE}}})</math>
and <math>h(\cdot)</math> is the [[binary entropy function]].

In the above equation for key length, the parameters <math>\epsilon_{\rm EC}</math> and <math>\epsilon'_{\rm EC}</math> are error probabilities of the classical error correction subroutine. At the end of the error correction step, if the protocol does not abort, then Alice and Bob share equal strings of bits with probability at least <math>1-\epsilon_{\rm EC}</math>. The parameter <math>\epsilon'_{\rm EC}</math> is related with the completeness of the error correction subroutine, namely that for an honest implementation, the error correction protocol aborts with probability at most <math>\epsilon'_{\rm EC}+\epsilon_{\rm EC}</math>.
The parameter <math>\epsilon_{\rm PA}</math> is the error probability of the privacy amplification subroutine and <math>\epsilon_{\rm PE}</math> is the error probability of the parameter estimation subroutine used to estimate <math>Q_X</math>
(see [[Quantum Key Distribution]] for the precise security definition).

==Protocol Description==
*'''Input:'''<math>n, \gamma, \epsilon_{\rm PA},\epsilon_{\rm PE},\epsilon_{\rm EC},\epsilon'_{\rm EC},Q_Z</math>
*'''Output:'''<math>K_A, K_B</math>
'''1.''' Distribution and measurement
#For <math>i=1,...,n</math>
## Alice chooses random bits <math>X_i\in\{0,1\}</math> and <math>A_i\in_R\{0,1\}</math> such that <math>P(X_i=1)=\gamma</math>
## Alice prepares <math>H^{X_i}|A_i\rangle</math> and sends it to Bob
## Bob announces receiving a state
## Bob chooses bit <math>Y_i\in_R\{0,1\}</math> such that <math>P(Y_i=1)=\gamma</math>
## Bob measures <math>H^{X_i}|A_i\rangle</math> in basis <math>\{H^{Y_i}|0\rangle, H^{Y_i}|1\rangle\}</math> with outcome <math>B_i</math>
''At this stage Alice holds strings <math>X_1^n, A_1^n</math> and Bob <math>Y_1^n, B_1^n</math>, all of length <math>n</math>.''

'''2.''' Sifting
#Alice and Bob publicly announce <math>X_1^n, Y_1^n</math>
#For <math>i=1,...,n</math>
## If <math>X_i=Y_i</math>
### <math>A_1^{n'} = A_1^{n'}.</math>append<math>(A_i)</math>
### <math>B_1^{n'} = B_1^{n'}.</math>append<math>(B_i)</math>
### <math>X_1^{n'} = X_1^{n'}.</math>append<math>(X_i)</math>
### <math>Y_1^{n'} = Y_1^{n'}.</math>append<math>(Y_i)</math>
''Now Alice holds strings <math>X_1^{n'}, A_1^{n'}</math> and Bob <math>Y_1^{n'}, B_1^{n'}</math>, all of length <math>n'\leq n</math>.''

'''3.''' Parameter estimation
# Set size<math>Q</math> = 0
#For <math>i=1,...,n'</math>
## If <math>X_i = Y_i = 1</math>
### Alice and Bob publicly announce <math>A_i, B_i</math>
### Alice and Bob compute <math>Q_i = 1 - \delta_{A_iB_i}</math>, where <math>\delta_{A_iB_i}</math> is the Kronecker delta
## size<math>Q</math> += 1;
#Both Alice and Bob, each, compute <math>Q_X = \frac{1}{\text{size}Q} \sum_{i=1}^{n'}Q_i</math>
'''4.''' Error correction

''<math>C(\cdot,\cdot)</math> is an error correction subroutine (see [[BB84 Quantum Key Distribution #References| [9]]]) determined by the previously estimated value of <math>Q_Z</math> and with error parameters <math>\epsilon'_{\rm EC}</math> and <math>\epsilon_{\rm EC}</math>
#Both Alice and Bob run <math>C(A_1^{n'},B_1^{n'})</math>''.
#Bob obtains <math>\tilde{B}_1^{n'}</math>
'''5.''' Privacy amplification

''<math>PA(\cdot,\cdot)</math> is a privacy amplification subroutine (see [[BB84 Quantum Key Distribution #References| [10]]]) determined by the size <math>\ell</math>, computed from equation for key length <math>\ell</math> (see [[Quantum Key Distribution#Properties|Properties]]), and with secrecy parameter <math>\epsilon_{\rm PA}</math>''
#Alice and Bob run <math>PA(A_1^{n'},\tilde{B}_1^{n'})</math> and obtain secret keys <math>K_A, K_B</math>;

==Simulation and benchmark==
A simulation code for benchmarking the QKD protocol is available [https://github.com/LiaoChinTe/netsquid-simulation/tree/main/QKD/E91 here].
Hardware parameter analysis can be found in the following [https://cloud.veriqloud.fr/index.php/s/iiw1SxU4D22FyQ7 preprint]

==Further Information==
# [https://core.ac.uk/download/pdf/82447194.pdf BB(1984)] introduces the BB84 protocol, as the name says, by Charles Bennett and Gilles Brassard.
# [https://quantum-journal.org/papers/q-2017-07-14-14/ TL(2017)] The derivation of the key length in [[BB84 Quantum Key Distribution#Properties|Properties]], combines the techniques developed in this article and minimum leakage error correcting codes.
# [https://tspace.library.utoronto.ca/bitstream/1807/10010/1/Lo_6438_2610.pdf GL03] gives an extended analysis of the BB84 in the finite regime.
# Sifting: the BB84 protocol can also be described in a symmetric way. This means that the inputs <math>0</math> and <math>1</math> are chosen with the same probability. In that case only <math>1/2</math> of the generated bits are discarded during the sifting process. Indeed, in the symmetric protocol, Alice and Bob measure in the same basis in about half of the rounds.
# [https://dl.acm.org/citation.cfm?id=1058094 LCA05] the asymmetric protocol was introduced to make this more efficient protocol presented in this article.
# A post-processing of the key using 2-way classical communication, denoted [[Advantage distillation]], can increase the QBER tolerance up to <math>18.9\%</math> (3).
# We remark that in [[BB84 Quantum Key Distribution#Pseudo Code|Pseudo Code]], the QBER in the <math>Z</math> basis is not estimated during the protocol. Instead Alice and Bob make use of a previous estimate for the value of <math>Q_Z</math> and the error correction step, Step 4 in the pseudo-code, will make sure that this estimation is correct. Indeed, if the real QBER is higher than the estimated value <math>Q_Z</math>, [[BB84 Quantum Key Distribution#Pseudo Code|Pseudo Code]] will abort in the Step 4 with very high probability.
# The BB84 can be equivalently implemented by distributing [[EPR pairs]] and Alice and Bob making measurements in the <math>Z</math> and <math>X</math> basis, however this required a [[entanglement distribution]] network stage.
#[https://doi.org/10.1007/3-540-48285-7_35 Secret-Key Reconciliation by Public Discussion]
#[https://arxiv.org/abs/quant-ph/0512258 Security of Quantum Key Distribution]

<div style='text-align: right;'>''contributed by Bas Dirke, Victoria Lipinska, Gláucia Murta and Jérémy Ribeiro''</div>

User:Harold

2019-11-10T21:26:54Z

Harold:

Harold Ollivier

User:Harold

2019-11-10T21:26:20Z

Harold: Created page with "Harold can be contacted at harold.ollivier@mines.org"

Harold can be contacted at harold.ollivier@mines.org