ARTICLES
PUBLISHED ONLINE: 7 DECEMBER 2008 DOI: 10.1038/NPHYS1150
Simplifying quantum logic using
higher-dimensional Hilbert spaces
Benjamin P. Lanyon1*, Marco Barbieri1, Marcelo P. Almeida1, Thomas Jennewein1,2, Timothy C. Ralph1,
Kevin J. Resch1,3, Geoff J. Pryde1,4, Jeremy L. OBrien1,5, Alexei Gilchrist1,6 and Andrew G. White1
Quantum computation promises to solve fundamental, yet otherwise intractable, problems across a range of active elds of
research. Recently, universal quantum logic-gate sets—the elemental building blocks for a quantum computer—have been
demonstrated in several physical architectures. A serious obstacle to a full-scale implementation is the large number of
these gates required to build even small quantum circuits. Here, we present and demonstrate a general technique that
harnesses multi-level information carriers to signi cantly reduce this number, enabling the construction of key quantum
circuits with existing technology. We present implementations of two key quantum circuits: the three-qubit Toffoli gate and
the general two-qubit controlled-unitary gate. Although our experiment is carried out in a photonic architecture, the technique
is independent of the particular physical encoding of quantum information, and has the potential for wider application.
The realization of a full-scale quantum computer presents oneof the most challenging problems facing modern science.Even implementing small-scale quantum algorithms requires
a high level of control over multiple quantum systems. Recently,
much progress has been made with demonstrations of universal
quantum gate sets in a number of physical architectures including
ion traps1,2, linear optics3–6, superconductors7,8 and atoms9,10. In
theory, these gates can now be put together to implement any
quantum circuit and build a scalable quantum computer. In
practice, there are many significant obstacles that will require both
theoretical and technological developments to overcome. One is
the sheer number of elemental gates required to build quantum
logic circuits.
Most approaches to quantum computing use qubits—the
quantum version of bits. A qubit is a two-level quantum system that
can be representedmathematically by a vector in a two-dimensional
Hilbert space. Realizing qubits typically requires enforcing a two-
level structure on systems that are naturally far more complex
and which have many readily accessible degrees of freedom,
such as atoms, ions or photons. Here, we show how harnessing
these extra levels during computation significantly reduces the
number of elemental gates required to build key quantum circuits.
Because the technique is independent of the physical encoding
of quantum information and the way in which the elemental
gates are themselves constructed, it has the potential to be used
in conjunction with existing gate technology in a wide variety of
architectures. Our technique extends a recent proposal11, and we
use it to demonstrate two key quantum logic circuits: the Toffoli
and controlled-unitary12 gates. We first outline the technique in
a general context, then present an experimental realization in a
linear optic architecture: without our resource-saving technique,
linear optic implementations of these gates are infeasible with
current technology.
1Department of Physics and Centre for Quantum Computer Technology, University of Queensland, Brisbane 4072, Australia, 2Institute for Quantum Optics
and Quantum Information, Austrian Academy of Sciences, Boltzmanng. 3, A-1090 Vienna, Austria, 3Institute for Quantum Computing and Department of
Physics & Astronomy, University of Waterloo, N2L 3G1, Canada, 4Centre for Quantum Dynamics, Grif th University, Brisbane 4111, Australia, 5Centre for
Quantum Photonics, H. H. Wills Physics Laboratory and Department of Electrical and Electronic Engineering, University of Bristol, Merchant Venturers
Building, Woodland Road, Bristol BS8 1UB, UK, 6Physics Department, Macquarie University, Sydney 2109, Australia. *e-mail: lanyon@physics.uq.edu.au.
Simplifying the Toffoli gate
One of the most important quantum logic gates is the Toffoli12—
a three-qubit entangling gate that flips the logical state of the
‘target’ qubit conditional on the logical state of the two ‘control’
qubits. Famously, these gates enable universal reversible classical
computation, and have a central role in quantum error correction13
and fault tolerance14. Furthermore, the combination of the Toffoli
and the one-qubit Hadamard offers a simple universal quantum
gate set15. The simplest known decomposition of a Toffoli when
restricted to operating on qubits throughout the calculation is a
circuit that requires five two-qubit gates12. If we further restrict
ourselves to controlled-z (or cnot) gates, this number climbs to
six12 (Fig. 1a). A decomposition that requires only three two-qubit
gates11 is shown in Fig. 1b. The increased efficiency is achieved by
harnessing a third level of the target information carrier—the target
is actually a qutrit with logical states |0〉, |1〉 and |2〉.
At the input and output of the circuit, information is encoded
only in the bottom two (qubit) levels of the target. The action of the
first Xa gate is to move information from the logical |0〉 state of the
target into the third level (|2〉), which then bypasses the subsequent
two-qubit gates. The final Xa gate then coherently brings this
information back into the |0〉 state, reconstructing the logical qubit.
By temporarily storing part of the information in this third level,
we are effectively removing it from the calculation—enabling the
subsequent two-qubit gates to operate on a subspace of the target.
This enables an implementation of the Toffoli with a significantly
reduced number of gates. Note that only standard two-qubit gates
are necessary, with the extra requirement that they act only trivially
on (that is, apply the identity to) level |2〉 of the qutrit. As such, it is
not necessary to develop a universal set of gates for qutrits.
This technique can be readily generalized to implement
higher-order n-control-qubit Toffoli gates (nt) by harnessing a
single (n+1)-level information carrier during computation and
134 NATURE PHYSICS | VOL 5 | FEBRUARY 2009 | www.nature.com/naturephysics

NATURE PHYSICS DOI: 10.1038/NPHYS1150 ARTICLES
X
a
T
a
b
C
2
TH
T
†
1
0
X
a
=
Qubit
Qubit
Qutrit
Qubit operators
Qutrit operator
T
X
H
Z
pi
X
H H
C
1
C
2
C
1
T
H
T
†
T
T
†
T
†
T
X
a
00
00
00
1
1
1
e
ipi/4
0
0
1
11
1–1
e
i θ
01
0
1
1
0
02
1
1
1
1
0
0
0
0
0
0 0
0
0
0
0
0
1
0
0
0
1
0
0
0
1
0
0
0 –1
0
0
0
1
θ
Z
Figure 1 | Simplifying the Toffoli gate. a, Most efcient known
decomposition into the universal gate set CNOT+arbitrary one-qubit gate,
when restricted to operating on qubits12. b, Our decomposition requiring
only three two-qubit gates11. Here, the target is a three-level qutrit' with
logical states |0〉, |1〉 and |2〉. Initially and nally, all of the quantum
information is encoded in the |0〉 and |1〉 levels of each information carrier.
The action of the Xa gates is to swap information between the logical |0〉
and |2〉 states of the target. The target undergoes a sign shift only for the
input term |C2,C1,T〉=|1,0,1〉. This operation is equivalent to the Toffoli
under the action of only three one-qubit gates, as shown. The second gate
in the decomposition is a CZ and is equivalent to a CNOT under the action of
two one-qubit Hadamard (H) gates.
only 2n−1 standard two-qubit gates11; that is, with each extra
control qubit we need an extra level in the target carrier (see
Fig. 2). Compare this with the previous best known scheme, which
requires 12n−11 two-qubit gates and an extra overhead of n−1
extra ancilla qubits12. When restrained from using ancilla, this
scheme requires of the order of n2 two-qubit gates. In either case,
we achieve a significant resource reduction, by harnessing only
higher levels of existing information carriers. For example, the
simplest knowndecomposition of the 5t requires 50 two-qubit gates
and four ancilla qubits, when restricted to operating on qubits12.
Our technique requires only nine two-qubit gates and no ancillary
information carriers.
Extension to more general quantum circuits
Figure 3 shows an extension to simplify the construction of
another key quantum circuit: the n-control-qubit unitary gate
(cnu), which applies an arbitrary one-qubit gate (u) to a target
conditional on the state of n control qubits. These circuits
have a central role in quantum computing, particularly in
the phase-estimation algorithm12. Phase estimation underpins
many important applications of quantum computing including
quantum simulation16 and Shor’s famous algorithm for factoring17.
Furthermore, the set of c1u gates alone is sufficient for universal
quantum computing; a c1u can implement a cnot and induce
any single-qubit rotation at the expense of an ancilla qubit. Our
technique can implement a cnuusing an (n+1)-level target and only
2n two-qubit gates. This is a similar improvement, over schemes
limited to qubits, to that achieved for the Toffoli12. Figure 4 shows
a further generalization to efficiently add control qubits to an
arbitrary controlled-unitary that operates on k qubits.
Potential for application
The technique that we describe is independent of the particular
physical system used to encode quantum information and the
1
0
1
0
T
C
3
H H
C
2
C
1
X
a
X
b
X
b
X
a
Figure 2 | Simplifying higher-order Toffoli gates. Three-control-qubit
Toffoli11. The Xa gate swaps information between the logical |0〉 and |2〉
states of the target. The Xb gate ips information between the logical |1〉
and |3〉 state of the target. Thus, we require access to a four-level target
information carrier: two levels in the original rail and one in each of the
dashed rails. The target undergoes a sign shift only for the input term
|C3,C2,C1,T〉=|1,1,1,1〉. This operation is equivalent to the Toffoli under the
action of only two one-qubit gates, as shown. See Fig. 1 for gate operations.
X
a
T
T
C
1
V U V
†
1
01
0
1
0
C
2
C
1
V U V
†
X
b
X
b
X
a
X
a
X
a
a
b
θ
Z
θ
Z
θ
Z
θ
Z
Figure 3 | Simplifying controlled-unitary gates. a, One control qubit (we
implement a simpli ed version, see Fig. 5): the control operation occurs if
|C1〉=|0〉. b, Two control qubits: the control operation occurs if
|C2,C1〉=|1,1〉. VZθV† is the spectral decomposition of U, up to a global
phase factor. See Fig. 1 for gate operations.
way in which the elemental gates are realized. Consequently, it
has the potential for application in many architectures, yielding
the same resource savings. The only physical requirements are
access to multi-level systems and the ability to coherently swap
information between these levels, that is, implement the generalized
Xa gates (Fig. 2).
Fortunately, most of the candidate systems for encoding
quantum information naturally offer multi-level structures that
are readily accessible. For example, the photon has a large number
of degrees of freedom including polarization, transverse spatial
mode, arrival time, photon number and frequency. Coherent
control over and between many of these dimensions has already
been demonstrated and shown to offer significant advantages in
a range of applications such as quantum communication and
measurement18,19. Trapped ions also offer readily accessible levels
including multiple electronic and vibrational modes. Indeed,
both linear optic20 and trapped-ion21,22 quantum computing
architectures already routinely use multi-level systems to
implement two-qubit gates and realize universal gate sets. Clearly
the tools are available to exploit our technique, the benefits
of which lie at the next level of construction—building large
quantum circuits.
An immediate benefit of a significant reduction in the number
of two-qubit gates required for quantum circuits is an equally
significant speed-up in processing time. This has particular
advantages in the many cases where short coherence times are an
obstacle in the path to scalability. Furthermore, as we illustrate in
the next section, our technique brings a whole range of logic circuits
NATURE PHYSICS | VOL 5 | FEBRUARY 2009 | www.nature.com/naturephysics 135