Unitary time evolution

Time evolution of quantum systems is always given by

Unitary Transformations. If the state of a quantum system is
|ψi, then at a later time

|ψi → Û |ψi.

Exactly what this operator Û is will depend on the

particular system and the interactions that it undergoes. It
does not, however, depend on the state |ψi. This
means that time evolution of quantum systems is linear.
Because of this linearity, if a system is in state |ψi or |φi
or any linear combination, the time evolution is given by
the same operator:

(α|ψi + β|φi) → Û (α|ψi + β|φi) = αÛ |ψi + β Û |φi.

– p. 1/25
 The Schrödinger equation
As we have seen, these unitary operators arise from the
Schrödinger equation

d|ψi/dt = −iĤ(t)|ψi/~,

where Ĥ(t) = Ĥ † (t) is the Hamiltonian of the system.

Because this is a linear equation, the time evolution must
be a linear transformation. We can prove that this must be a
unitary transformation very simply.

– p. 2/25
Suppose |ψ(t)i = Û (t)|ψ(0)i for some matrix Û (t) (which we
don’t yet assume to be unitary). Plugging this into the
Schrödinger equation gives us:

dÛ (t) dÛ † (t)

= −iĤ(t)Û (t)/~, = iÛ † (t)Ĥ(t)/~.
dt dt

At t = 0, Û (0) = Iˆ, so Û † (0)Û (0) = Iˆ. We see that

d  †  1  
Û (t)Û(t) = Û † (t) iĤ(t) − iĤ(t) Û (t) = 0.
dt ~
So Û † (t)Û(t) = Iˆ at all times t, and Û (t) must always be
unitary.

– p. 3/25
For time-independent Hamiltonians we can easily write
down the solution to the Schrödinger equation. Using the
spectral theorem, we choose a basis {|ki} of eigenvectors of
Ĥ with eigenvalues Ek , Ĥ|ki = Ek |ki. We then write |ψ(t)i
in terms of this basis:
X X X
Ĥ = Ek |kihk|, |ψ(t)i = αk (t)|ki, |αk (t)|2 = 1.
k k k

Knowing |ψ(t)i = exp(−iĤt/~)|ψ(0)i for any t means know-

ing the amplitudes αk (t). From the Schrödinger equation,
dαk
= −iEk αk /~ =⇒ αk (t) = exp(−iEk t/~)αk (0).
dt
Each energy eigenstates undergoes a steady phase rotation.
– p. 4/25
 Bloch sphere rotation
Any 2 × 2 Hermitian operator can be written Ĥ = aIˆ + bX̂+
cŶ + dẐ with real a, b, c, d. Spin-1/2 unitaries take the form
 
Û (t) = exp −(it/~)(aIˆ + bX̂ + cŶ + dẐ)

We now need to use a very useful and important fact. For

general operators  and B̂ , usually

exp(Â) exp(B̂) 6= exp(Â + B̂).

The one exception to this is when [Â, B̂] = 0. In this case

only, exp(Â) exp(B̂) = exp(Â + B̂).

– p. 5/25
Since the identity commutes with everything,
 
it  
exp − aIˆ + bX̂ + cŶ + d
~
   
iat ˆ it  
= exp − I exp − bX̂ + cŶ + dẐ
~ ~
 
= e−iat/~ exp −(it/~)(bX̂ + cŶ + dẐ) .

Since an overall phase is meaningless, we can always set

a = 0. (This is not just true for spin-1/2; one can add or
subtract a term aIˆ to any Hamiltonian.)

– p. 6/25
The most general spin-1/2 Hamiltonian is therefore
ˆ
Ĥ = bX̂ + cŶ + dẐ = E0~n · ~σ

where p
E 0 = b 2 + c2 + d 2 ,
~n = (nx , ny , nz ) = (b/E0 , c/E0 , d/E0 ),
with n2x + n2y + n2z = 1 and ~σˆ = (X̂, Ŷ , Ẑ). The unitary is

ˆ.
exp(−iĤt/~) = cos(E0 t/~)Iˆ − i sin(E0 t/~)~n · ~σ

In the Bloch sphere picture this corresponds to a rotation

around the axis ~n at a rate E0 /~. This is the most general
unitary transformation possible for spin-1/2.
– p. 7/25
 Controlling unitaries
We generalize from steady rotation by assuming we can
turn the Hamiltonian on and off. By turning a Hamiltonian
on for a particular length of time, we can “rotate” the state
by a particular angle. For a spin-1/2, this means we can
perform unitary transformations of the form
ˆ.
Û (θ) = cos(θ/2)Iˆ − i sin(θ/2)~n · ~σ

We can do the same with more complicated systems. For a

D-dimensional system with a Hamiltonian Ĥ having
eigenvalues Ek and eigenvectors |ki, we can do the unitary
X
Û (τ ) = exp(−iEk τ /~)|kihk|
k

for any τ .
– p. 8/25
 Building up unitaries
Unfortunately, we cannot always choose the exact values of
the eigenvalues Ek or the eigenvectors |ki. These are
generally given to us by nature. But we sometimes can
increase the range of our options by combining several
different unitaries in a row. The important thing to remember
is that any product of unitary operators is also unitary:

Û † Û = V̂ † V̂ = Iˆ =⇒ (Û V̂ )† (Û V̂ ) = V̂ † Û † Û V̂ = I.
ˆ

Suppose there are two different Hamiltonians we can turn on:

Ĥ1 and Ĥ2 . Then we can perform the unitaries

Û1 (τ ) = exp(−iĤ1 τ /~), Û2 (τ ) = exp(−iĤ2 τ /~).

But we can do much more than these!

– p. 9/25
We can also do the unitaries

Û2 (τ2 )Û1 (τ1 ), and Û2 (τ3 )Û1 (τ2 )Û2 (τ1 ),

and Û2 (τn )Û1 (τn−1 ) · · · Û2 (τ2 )Û1 (τ1 ).

Let’s see how this works for the spin-1/2. Suppose we can
turn on Hamiltonians

Ĥ1 = Ex X̂, Ĥ2 = Ey Ŷ .

These produce unitaries Û1 (θ) and Û2 (θ) which correspond,
in the Bloch sphere representation, to rotations by θ about
the X and Y axes, respectively.

– p. 10/25
There is a theorem in geometry that a rotation by any
angle θ around any axis ~n can be done by doing three
rotations in a row around the X and Y axes:

R~n (θ) = RX (φ3 )RY (φ2 )RX (φ1 )

for some φ1 , φ2 , φ3 .
Since every 2 × 2 unitary is equivalent to a Bloch sphere
rotation about some axis ~n, any 2 × 2 unitary equals

ÛX (τ3 )ÛY (τ2 )ÛX (τ1 )

for some τ1 , τ2 , τ3 (up to an overall phase).

When we talk about “turning on” and “turning off”
Hamiltonians, what do we really mean?
– p. 11/25
Here is a picture to give some idea:

For many experimental systems, unitaries are effected by

turning precisely-tuned lasers on and off for precise lengths
of time.

– p. 12/25
 Tensor products of unitaries
We have seen that Hilbert spaces of composite systems are
represented by tensor products of the Hilbert spaces of the
component systems:

H12 = H1 ⊗ H2 .

Therefore, unitaries on the joint system also act on this

larger Hilbert space. Suppose that the Hamiltonian of a
system is a sum of terms which act only on the individual
subsystems:
Ĥ = Ĥ1 ⊗ Iˆ + Iˆ ⊗ Ĥ2 .
The two terms represent the Hamiltonian of the first and
second subsystems, respectively. In this Hamiltonian, the
two subsystems are isolated, and do not interact.

– p. 13/25
Ĥ1 ⊗ Iˆ and Iˆ ⊗ Ĥ2 commute, so

Û (t) = exp(−iĤt/~)
= exp(−i(Ĥ1 ⊗ Iˆ + Iˆ ⊗ Ĥ2 )t/~)
ˆ ~) exp(−iIˆ ⊗ Ĥ2 t/~)
= exp(−iĤ1 ⊗ It/
= exp(−iĤ1 t/~) ⊗ exp(−iĤ2 t/~)
≡ Û1 (t) ⊗ Û2 (t).

It is a tensor product of unitaries.

What if the Hamiltonian is not a sum of terms which act
on the individual subsystems, but includes terms which
act on both subsystems?

– p. 14/25
 Interactions and entanglement
If the Hamiltonian has the form

Ĥ = Ĥ1 ⊗ Iˆ + Iˆ ⊗ Ĥ2 + Ĥint ,

the unitary Û (t) = exp(−iĤt/~) will not be a tensor

product, in general. In this case, we say that the two
subsystems interact.
If a tensor-product unitary Û1 ⊗ Û2 acts on a product
state |ψi ⊗ |φi, then it will remain a product state. If a
general Û acts on it, generally the state becomes
entangled. Since most states are entangled, to produce
them from initial product states requires unitaries which
are not products. We must have interactions between the
subsystems to produce general unitary transformations.

– p. 15/25
Let’s take an example for two spin-1/2s: Ĥint = Eint Ẑ ⊗ Ẑ .
This yields unitary transformations of the form

Û (θ) = cos(θ/2)Iˆ − i sin(θ/2)Ẑ ⊗ Ẑ.

Suppose we have an initial product state |Ψi = |ψi ⊗ |φi

= α1 β1 | ↑↑i + α1 β2 | ↑↓i + α2 β1 | ↓↑i + α2 β2 | ↓↓i.

When we transform it by Û (θ) it becomes

Û (θ)|Ψi = e−iθ/2 α1 β1 | ↑↑i + eiθ/2 α1 β2 | ↑↓i

+eiθ/2 α2 β1 | ↓↑i + e−iθ/2 α2 β2 | ↓↓i,

which is no longer a product state for θ 6= mπ/2. The

interaction has produced entanglement.
– p. 16/25
 The no-cloning theorem
The restriction of time evolution to unitary operators
means that certain kinds of evolution are impossible. One
impossible task is quantum cloning.
Suppose we have a system in an unknown state |ψi,
and we wish to copy it, i.e., to transform a second system
starting in some standard state |0i into the same state
|ψi. Is there a unitary Û such that, for any state |ψi,

Û (|ψi ⊗ |0i) = |ψi ⊗ |ψi?

If this is true, then also for |φi 6= |ψi

Û (|φi ⊗ |0i) = |φi ⊗ |φi.

– p. 17/25
Consider now a superposition state |χi = α|ψi + β|φi.
By linearity,

Û (|χi ⊗ |0i) = Û (α|ψi + β|φi) ⊗ |0i

= α|ψi ⊗ |ψi + β|φi ⊗ |φi
6= (α|ψi + β|φi) ⊗ (α|ψi + β|φi),

so Û (|χi ⊗ |0i) 6= |χi ⊗ |χi, which is a contradiction.

Therefore, no such Û exists.
This is the famous no-cloning theorem: quantum
information, unlike classical information, cannot be copied.

– p. 18/25
This simple result has many profound consequences.
For one, the state |ψi of a system is not an observable. Given a
quantum system, there is no way to tell in what state |ψi
it was prepared.
If the state |ψi is known, the state can be “copied” by
preparing another system. But it is impossible to copy
an unknown quantum state.
This means that many techniques of classical
information theory (such as protecting information by
making redundant copies, or having a fanout gate from a
single bit) are impossible in quantum information theory.

– p. 19/25
 Quantum gates and circuits
We have seen that it is possible to build up new unitary
operators by multiplying together some set of standard
ones. This is rather analogous to the situation in classical
logic, where any Boolean function can be built up from a set
of standard functions of one or two bits, called logical gates:

We can similarly try to build up unitary transformations from

a set of standard unitaries. We will call these quantum gates.

– p. 20/25
First we define the basic unit of quantum information:
the quantum bit. This is the simplest possible quantum
system, one with two distinguishable states. In other
words, the quantum bit (or q-bit) is our old friend, the
spin-1/2! We take the standard basis to be |0i ≡ | ↑Z i,
|1i ≡ | ↓Z i.
The simplest gate, affecting only a single q-bit, is the
NOT gate:
|0i ↔ |1i.
We see that this is also a familiar operator: X̂ .
NOT is the only nontrivial one-bit classical gate. But in
quantum mechanics, there are far more possibilities.

– p. 21/25
One important example with no classical analogue is
the Hadamard gate:
!
1 1 1
ÛH = √ .
2 1 −1

We write these unitaries with a convention similar to

that of classical logic gates:

The wires of the circuit diagrams are q-bits, and the gates
are unitary transformations acting on those qubits.
(Such unitaries act on other q-bits as the identity.)
– p. 22/25
We can also define two-bit quantum gates. One
example is the controlled-not (CNOT):

ÛCNOT |00i = |00i, ÛCNOT |01i = |01i,

ÛCNOT |10i = |11i, ÛCNOT |11i = |10i.

Here we write the unitary as a two-bit gate where |ini

and |outi are now two-bit states:

– p. 23/25
 Quantum circuits
There are infinitely many possible two-bit gates; but in
practice such unitaries are difficult to do. Fortunately, it
turns out that just the CNOT (or almost any other two-bit
gate), together with one-bit gates, can be used to build
up any unitary. (We will prove this later in the class!)
When we combine standard unitary gates, we call the
resulting unitary a quantum circuit. Here’s a simple
example that uses three CNOT gates to swap the first
and second bits:

– p. 24/25
You can check that this this circuit does indeed swap
the two q-bits by acting with it on each of the basis
states for two q-bits:

|00i → |00i, |01i → |10i,

|10i → |01i, |11i → |11i.

Note that the control and target bits can all be switched,
and this will still be a swap gate.
A quantum circuit for a less trivial unitary will in general
be much more complicated. The problem of designing
quantum algorithms is largely the task of designing such
quantum circuits.
Next time: some simple examples with light.

– p. 25/25