File:WSE Sender.PNG

2019-07-16T10:02:36Z

Natansh:

Quantum Teleportation

2019-07-16T10:01:14Z

Natansh:

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.
</br></br>
'''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:</br>
* 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.

==Requirements==

[[File:ST_TP.PNG|center|State Teleportation (Third Party)]]

<br/>

[[File:ST_Sender.PNG|center|State Teleportation (Sender)]]

<br/>

[[File:ST_Receiver.PNG|center|State Teleportation (Receiver)]]

==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/apassenger/CQC-Python/tree/master/examples/pythonLib/teleport/Quantum%20State%20Teleportation <u>click here for SimulaQron code</u>]

*'''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.</br></br>
'''<u>Stage 1</u>''' Share entangled qubits (EPR pair)</br>
# 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:</br>
<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></br>
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>)</br></br>
<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></br></br>
'''<u>Stage 2</u>''' 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></br></br>

'''<u>Stage 3</u>''' 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></br></br>

'''<u>Stage 4</u>''' 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>

==Further Information==

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

File:ST Receiver.PNG

2019-07-16T09:57:53Z

Natansh:

File:ST Sender.PNG

2019-07-16T09:57:36Z

Natansh:

2019-07-16T09:47:57Z

Natansh: Natansh uploaded a new version of File:PSVUBQC Server.PNG

2019-07-15T22:31:45Z

Natansh: /* Requirements */

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.</br>

'''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]].

<br/>

[[File:QT_Bank.PNG|center|Quantum Token (Bank)]]

<br/>

[[File:QT_Client.PNG|center|Quantum Token (Client)]]

==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> </br>
'''Output:''' (Merchant) accept or reject</br>
<u>'''Stage 1'''</u> Preparation </br>
# 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).

<u>'''Stage 2'''</u> Interaction </br>
# Merchant asks client to measure a few qubit-pairs(say, a row) in a randomly chosen basis M \epsilon_R \{X,Z\}
# Client returns measurement outcome (m) for all qubit pairs asked to measure
<u>'''Stage 3'''</u> Transaction </br>
# 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

==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>