tutorial on quantum computing vwani p....
Post on 27-May-2018
216 Views
Preview:
TRANSCRIPT
Fundamentals
Qubits
A single qubit is a two–state system, such as a two–level atom
we denote two orthogonal states of a single qubit as������������ �Any state of this system can be in arbitrary superposition:
� ������� ������� � � ����� ��������� ��
� qubits
more generally, a system of � qubits represents a Hilbert space of
dimension "! , and the state of the “system” is a superposition of the
basic states # �%$&('*) � & �,+ & �-�# �%$&('*) � � & � � �
�,+ & �*� �/. ) . �*01010 . !��� . &32 4 �5�687
2
Entangeled States
Example 1: product state����������� ��� � �� � � ��� � ��� � �
��� �
������� � � � ����� �
������� � � � �
Example 2: EPR (Einstein–Podolsky–Rosen) pair�� �
����� � ��� � � �� �
3
Unitary Operations
��� ���� ���
Hadamard transformationa 1–qubit operation, denoted by � , and performs the
following transform
���� � � � ������� � � � ���
� � � � � � �������� � � � ��
NOTa 1–qubit operation
���� � � � ���� � � � �����
4
Measurement
Example 1:��� � �
� ������� � � ����
measurement ���� �������
with probability)�����
with probability��
Example 2: partial measurement�
���5� � �� �����first system measured ���� �����
with probability)� and the system collapses to
������
with probability)� and the system collapses to
�����
Example 3: ����� )
����� � � ��� � ��� ��� )
����� � � ��� � �first system measured ���� �����
the system collapses to) �
����� � � ��� � ����the system collapses to
) � ����� � � ��� � �
5
Quantum Teleportation
There are two players: Alice and Bob.
Alice is given a quantum system��� � � unknown to her.
Alice Bob�
��� � �
classical channel
Alice wants to send sufficient information about��� � �
so that Bob is able to make an accurate copy of it.
Alice is not allowed to transform the original particle.
Alice Bob
���� � �
6
Suppose Alice and Bob each has a particle of an EPR
pair:
Alice Bob�
��� � ��
��� ����
��� � �
EPR pair ��� ���
��� � � � � ���� � � � � � � � � � � � ��� � � � �
EPR pair:��� � � � �
� ��� ���� � � � ��� � � � � � ��������
7
the state of the three particles:��� � � ��� � � � �
� � ���� � � � � � � � �� � � ���� � � � � � � � � � � ���� ���
��� � � ���� � ���� � � � � � � ���� � � � � � ���� � �
�� � � � � � � ���� � � � � � � � � � � � � � � ���� ���
It can be written as
��� ��� � � � � � � ������ � � � � ��� � �� ��� � � � � � � ���� � � � � � � �
�� ��� � � � � � ���� � � � � � � � �� ��� � � � � � � ���� � � � � � � �
8
where
��� � � � ��� � � ���� � � � � � � � � � ���� � �
��� � � � ��� � � ���� � � � � � � � � � � ���� � �
��� � � � ��� � � ���� � ���� � � � � � � � � � �
��� � � � ��� � � ���� � ���� � � � � � � � � � � �
The four states
��� � � � � ��� � � � � ��� � � � � ��� � � �
are a complete orthonormal basis for particles 1 and 2.
9
Alice measures in Bell operator basis of� ��� � � � � ��� � � � � ��� � � � � ��� � � � � the joint system
consists of the particle 1 (i.e.,��� � � ) and the particle 2
(her EPR particle).
Regardless of the unknown state��� � � , the four
measurment outcomes are equally likely.
After Alices’s measurment, Bob’s particle 3 will be
projected into one of the following four pure states:
result of Alice’s measurment Bob’s particle 3��� � � � ��� ��� � ���� � � � ��� � �� ��� ��� � ���� � � � � � �� � � ��� � ���� � � � � � �
� � ��� ��� � �
Alice, via the classical channel, sends the result of the
measurement. Then Bob performs the corresponding
unitary opertaor on his particle.
10
Communication Complexity
Alice Bob�
��
�
Alice and Bob are provided with binary strings � and� .
goal: Alice has to determine � � � � � � , where
� � � � � ����� � � ��� � � � � ��� ��� � � � ��� �
with as little communication between Alice and Bob as
possible.
11
trivial solution: Bob sends all his � bits to Alice.
nontrivial question: Can this be done with
communicating less than � bits?
Two–party communication complexity of the
function � is the minimum number of bits that must be
communicated between Alice and Bob in order for
Alice to compute � � � � � � .
Generalization to more than two parties is
straightforward.
12
Example 1: The parity function
� � � � � � � � ��� ������� � � � ��� ������� � �
: addition modulo two.
It suffices for Bob to send a single bit (i.e.,� ��� ������� � ) to Alice.
Example 2: The inner product modulo two
��� � � � � � � � � � � � � � � ������� � � � � �
It is proved that � bits of communication is necessary.
That is, there is no communication protocol that
allows Alice to compute��� � � � � � if the total number
of bits communicated is less than � .
Question: If Alice and Bob share quantum entangled
particles, is it possible to reduce the communication
complexity?
13
There are � parties. The party���
receives� ��� � � � � � � � � ���
. The inputs satisfy���� � � � mod� � � � �
The goal is to compute
� � � � � � � � � � �� � �
���� � � � mod� �
which is always is 0 or 1.
The classical communication complexity of�
is� �� ���� � � .
If parties share entangled particles then�
can be
computed by communicating � bits.
14
The parties share the cat state
��� � ����� � � � � �� � � ����� ����� ��� � ��� ����� � � � �
where the party� �
holds the qubit� �
.
15
the protocol:
(1) Each party� �
applies the phase–change operator
���� � ����
� � � � � ������� �� $ � � �
on his qubit� �
.
(2) Each� �
applies the Hadamard transform
���� � �� � � ����� � � � �
� � � � �� � � ������ � � � �
on his qubit� �
.
(3)� �
measures his qubit� �
in the basis� ������ � � � �
,
and sends the outcoming bit� �
to the others.
Then� � � � � � � � � � � ��� ������� � � .
16
Why is this protocol correct?
After applying the phase–change operator, the
entangled state becomes�� � � ����� ����� ��� � ������ $���������������� �� � ��� ����� � � �
The Hadamard transform results in (with�
� $�� �factor)
����� ��� ��� $��� � � ������ $���������������� ��
����� ��� ��� $� � � � � � � ��� �
or
����� ��� ��� $��� � � � � ��� ����� ���� � �� ��
����� ��� ��� $� � � � � � � ��� �
which is � even
��� �if� � � � � � � � � � �
, and
� odd
��� �otherwise.
17
The RSA public key cryptosystem
plain message � ���
Alice
� � � plain message
Bob
� �private file
�
� �public file
�open channel
�Eve
18
private file
prime numbers: � and �� �� � �
integres � and � such that � � ��� � (mod � � � � �where � � � � � least common multiple � � � � � � � � �
public file�
and �
� � � � � � � � mod � �
� � � � � � � � mod � �
It holds that
� � � � � � � � � � � � � mod � � � �
19
Example:
� � � � � � � � then � � ���
� � � � � l.c.m.��� ��� � � �
chose� � � � � then
� �� � � �mod
� � � �� � �
public file: � � ��� and� � � �
If the plaintext is� � ��� then the ciphertext is
� � ��� � � ������ �
mod ��� � � �
Bob uses� � � � � ��� �
mod ��� � � ��� to obtain the
plain text�
.
20
Quantum Cryptography
plain message � encryption
Alice
decryption � plain message
Bob
�open channel
�Eve
� �
key
Quantum channel
21
Generating quantum key distribution:
Alice and Bob generate their own independent sets of
random numbers:
Alice 0 0 1 0 1 1 0 1 0 1�����
Bob 1 0 0 0 1 0 1 1 0 0�����
They try to find a suset of identical bits in their sets of
random bits.
Alice * 0 * * 1 * * 1 * *�����
Bob * 0 * * 1 * * 1 * *�����
The result is their common key:
� � � �����
22
How to find the common bits securely?
Alice sends, through a quantum channel, the following
quantum states for each bit in her set
bit state� ��� � � � ����� ��� � � � �
� ������� � � � �
Bob makes a measurement on each state he receives.
The measurement depends on his corresponding bit.
bit measurement� ��������� �
where��� � � � �
� �������� � � � �
� ����� � � � where��� � � � � � �
23
Measurement� � � � is a projection opertor
��� � � � � � ��� � �
The result of this measurement on state��� �
is
� � � ��� �� � � � ��� � � , with probability� � � � � � � ��� �
,
� � � � � � � ��� �� � � � � � � � ��� � � , with probability� � � � � � � � � ��� �
,
24
The probability of Bob’s measurement results:
Alice’s bit Bob’s bit measurement result probability decision
0 0��� � � �� Y
0 0��� � � �� N
0 1��� � �
1 N
1 0��� � �
1 N
1 1��� � � �� Y
1 1��� � � �� N
Y=“pass”; Bob observes��� �
when he makes the projection�������
.
N=“fail”.
If the bits are different, the decision is always “N”. If Bob and Alice
have the same bit then with probability)� the decision is “Y”.
25
Bob sends the sequence of Y–N decisions to Alice over
a public channel.
They keep only the bits for which the decision is “Y”.
The result becomes the shared key.
26
Deutsch’s Algorithm: Fault Detection (?)
A Boolean function � � � � � ��� ��� � � � ���is given.
It is known that either � is constant or balanced (i.e.,
takes values 0 and 1 an equal number of times). The
problem is to decide whether � is constant or
balanced.
� � �
����
����
����
��
��
����
��
measurement
� � � � � ��� � � � � � � � � � � � � � �
� ��� �
� � �� � ���
27
Step 1: prepare the state
����� ����� �� �������� � � � � �
where the first register consists of � qubits.
Step 2: perform the Hadamard transform on the first �
qubits
� ��� ��� ��� $� � � �������� � � � ��
�� ��� ��� ��� $
� � ��������� ��� ��� ��� $
� � � � � ��
28
Step 3: apply� � � � � ��� � � � � � � � � � � � � � �
� ��� ��� ��� $� � ����� � � � � � � �
� ��� ��� ��� $� � ��� � � � � � � ��
note that for� � � � � ���
��� � � ��� � � � � � � � � � ��� �������� � � � ��
so the result of this step is��� ��� ��� ��� $
� � � � � ��� � � � ���� �������� � � � ��
note that
� ��� ��� ��� $� � � � � ��� � � � �
�� ��� � � � #
� ��� ��� ��� $ � � � if � is constant,��� �if � is balanced,
where��� �
is orthogonal to��� �
.
29
Step 4: apply the Hadamard transform � on the first
� qubits
note that
� ��� � � � ����� ����� ��
because � � � � �� ��� �
is orthogonal to � ��� � � � ����� ����� ��,
because the unitary operation � maps orthogonal
states to orthogonal ones.
the final result
if � is constant � ����� ����� �� �������� � � � �
if � is balanced��� � �������� � � � �
where��� �
is orthogonal to����� ��� � ��
measure the first � qubits
� is constant if and only if we observe � zeros
30
Grover’s algorithm: Quantum search
A Boolean function �� � � � ��� ��� � � � ���
such
that �� � � � �
for only one value � � � � .Find: � � .We assume that � can be evaluated in unit time.
Any classical algorithm (deterministic or probabilistic)
for this problem needs to check at least�� � vectors of� � � ���
.
Grover’s algorithm shows the quantum computer can
solves this problem in time �� � � � .
31
Fix � � � � � ��� , we define the unitary operator
���as
for� � � � � ����� � � �
� $,��� ��� � � � � � � � � � if � � � � � � � otherwise.
We will apply� �
, for � � �, and
� � � . The operator� �can be computed efficiently (in time polynomial in
� );
In the beginning we do not know � � , but still it is
possible to compute� � � efficiently, if we assume that
�� � � can be computed efficiently on each given input
� � � � � ��� .
The algorithm is based on iteration of the following
transform:
� � � � � � � � � �
32
First we prepare the uniform superposition
��� � � � � �� �� ��� ��� ��� $
� � �
Then we apply the transform
on��� �
repeatedly
The operator
maps each superposition of the form
� � � � �� �
���� � �� � �
to itself.
33
Initially � � � � � ��
� � and after � iteration of
, for ������� �
� � $ ,
�� � ����� � � � � � � � ���� � �
�� � � �� ��� � � � � � � � ���
After�
iterations the probability of measuring � � ,i.e.�� � , is very close to 1 if
� � ��� �� � ��
34
��� �
��� � �����
� � �
����
� � �
���� �����������
� � � � � � ��� � � ��
�
� �
Computing the unitary operator� � �
35
top related