Datasets:
wesley7137
/
quantum

Dataset card Data Studio Files
xet
 Community
text
stringlengths
0
8.13M
0 i
system| callei H⊗n,
The quantum H is d qubit. We have H = ǫ ,...,ǫ =
1 n 1 | n−1 0 i
ǫ ǫ .
n−1 0
| i⊗···⊗| i
This conforms to the general principles of quantum mechanics. The Hilbert
space of the union of systems can be identified with the tensor product of the
Hilbert spaces of the subsystems. Accordingly, decomposable vectors correspond
to the states of the compound for which one can say that the individual subsystems
are in definite states.
(B) Pure quantum states, strictly speaking, are points of the projective space
P(H ) that is, complex lines in H . Traditionally, one considers instead vectors
n n
of norm one. This leaves undetermined an overall phase factor expiϕ. If we have
two state vectors, individual phase factors have no objective meaning, but their
quotient, that is the difference of their phases, does have one. This difference
can be measured by observing effects of interference. This possibility is used for
implementing efficient quantum algorithms.
(C)If a quantum systemS isisolated, itsdynamical evolutionisdescribed by the
unitary operator U(t) = expiHt where H is the Hamiltonian, t is time. Therefore
one option for implementing U physically is to design a device for which U
F F
would be a fixed time evolution operator. However, this seemingly contradicts
many deeply rooted notions of the algorithm theory. For example, calculating F(x)
for different inputs x takes different times, and it would be highly artificial to try
to equalize them already in the design.
Instead, one can try to implement U as the result of a sequence of brief interac-
F
tions, carefully controlled by a classical computer, of S with environment (say, laser
pulses). Mathematically speaking, U is represented as a product of some standard
F
unitary operators U ...U each of which acts only on a small subset (two, three)
m 1
of classical bits. These operators are called quantum gates.
The complexity of the respective quantum computation is determined by its
length (the number m of the gates) and by the complexity of each of them. The
latter point is a subtle one: continuous parameters, e.g. phase shifts, on which U
i
may depend, makes the informationcontent of each U potentially infinite and leads
i
toasuspicionthata quantumcomputer willinfact performananalogcomputation,
only implemented in a fancy way. A very interesting discussion in [Ts], Lecture 9,
convincingly refutes this viewpoint, by displaying those features of quantum com-
putation which distinguish it from both analog and digital classical information
processing. This discussion is based on the technique of fault tolerant comput-
ing using quantum codes for producing continuous variables highly protected from
external noise.
16
(D) From the classical viewpoint, the requirement that F must be a permutation
lookshighlyrestrictive(forinstance, inthesearchproblemF takesonlytwovalues).
Physically, the reason for this requirement is that only such F extend to unitary
operators (“quantum reversibility”). The standard way out consists of introducing
two n–bit registers instead of one, for keeping the value of the argument as well
as that of the function. More precisely, if F( x ) is an arbitrary function, we can
| i
replace it by the permutation F( x,y ) := x,F(x) y , where is the Boolean
| i | ⊕ i ⊕
(bitwise) sum. This involves no more than a polynomial increase of the classical
e
complexity, and the restriction of F to y = 0 produces the graph of F which we
need anyway for the type of problems we are interested in.
e
In fact, in order to process a classical algorithm (sequence of Boolean gates) for
computing F into the quantum one, we replace each classical gate by the respective
reversible quantum gate, i.e. by the unitary operator corresponding to it tensored
by the identical operator. Besides two registers for keeping x and F( x ) this
| i | i
trick introduces as well extra qubits in which we are not particularly interested.
The corresponding space and its content is sometimes referred to as “scratchpad”,
“garbage”, etc. Besides ensuring reversibility, additional space and garbage can be
introduced as well for considering functions F : 0,...,N 1 0,...,M 1
{ − } → { − }
where N, M are not powers of two (then we extend them to the closest power of
two). For more details, see the next section.
Notice that the choice of gate array (Boolean circuit) as the classical model
of computation is essential in the following sense: a quantum routine cannot use
conditional instructions. Indeed, to implement such an instruction we must observe
the memory in the midst of calculation, but the observation generally will change
its current quantum state.
In the same vein, we must avoid copying instructions, because the classical copy-
ing operator x x x is not linear. In particular, each output qubit from a
| i → | i⊗| i
quantum gate can be used only in one gate at the next step (if several gates are
used parallelly): cloning is not allowed.
These examples show that the basics of quantum code writing will have a very
distinct flavor.
We now pass to the problems posed by the input/output routines.
Input, or initialization, in principle can be implemented in the same way as a
computation: we produce an input state starting e.g. from the classical state 0
| i
and applying a sequence of basic unitary operators: see the next section. Output,
however, involves an additional quantum mechanical notion: that of observation.
(E) The simplest model of observation of a quantum system with the Hilbert
space H involves the choice of an orthonormal basis of H. Only elements of this
basis χ can appear as the results of observation. If our system is in some state ψ
i
| i | i
at the moment of observation, it will be observed in the state χ with probability