[MUSIC PLAYING] DANIEL SANK:
Information is physical. Written letters are
carbon grains on paper. Spoken words are vibrations
of air molecules. Computer bits are
electric charge. Each of these examples
shares a common limitation-- they work under physics that was
understood in the 1800s, known as classical physics. Science has
progressed since then. We've discovered a new set of
laws called quantum mechanics. Here's one of our chips
designed to leverage the rules of quantum mechanics
to process information in ways impossible on a computer
based in classical physics. You may have heard that
quantum mechanics only applies to microscopic
objects, like atoms. So how does this chip
bring out quantum behavior? I'm Daniel Sank, a research
scientist working in the Google AI Quantum Computing Lab. In this video, we'll
look at how our quantum bits are made physically. I want to explain the
fundamental differences between classical and
quantum information at the physical
level so that you can understand why our quantum
bits are made how they are. Physicists and
computer scientists both think in terms of states. A physical state
could be my position-- I can be on the left
or on the right. And physical laws determine
how nature goes from one state to another. Observe. If Sergio pushes me,
my state changes. A computer's state is the
value of its memory bits and computer programs
determine how the computer goes from one state to the next. For example, when you
hit the Play button, YouTube's program started
manipulating your computer's memory to show this video. Where physics has physical
states and natural laws, computer science has
memory states and programs. Think of the state of computer
memory as a string of bits. For end bits, there are two
to the end possible strings. But because we're based
in classical physics, the state of the
computer is just one of these states at
each point in time. On each step of a classical
algorithm, we go from one state to the next. For example, the logic
operation shown here takes the state 0-0-0 to 1-1-0. If we were to apply the
same operation again, we'd go from 1-1-0 to 0-1-0. Compared to classical states,
quantum states are more rich. They can have weight in all
possible classical states, a situation physicists
call superposition. Each step of a quantum
algorithm mixes the states into complex superpositions. For example,
starting in 0-0-0, we go to a superposition of
1-0-0, 1-0-1, and 1-1-1. Then each of those three
parts of the super post state branches out
to even more states. The extra complexity
of quantum computers allows them to
solve some problems faster than a classical
computer ever could. We've discussed the
computational difference between classical
and quantum, but how do classical and quantum
differ physically? How do we bring out
quantum mechanics in our chip, which
is so much bigger than the tiny atoms in
which quantum mechanics was first discovered? Let's take a detailed
look at classical bits at the physical
level so that we can understand the physical
difference between classical and quantum. Classical computer
bits are stored in the presence or
absence of charge on a capacitor in
a circuit called dynamic RAM, or DRAM for short. If there's charge,
it's a logical 1, and if there's no
charge, it's a logical 0. But there's more going on here. Our logical 0 and 1
are actually made up of the presence or absence
of 300,000 electrons. Why use so many? In principle, we could just use
the presence or absence of one electron as our logical bid. Well, physical bits are noisy. Electrons are tiny and light, so
they jiggle around and leak out of the DRAM. If we had only one electron
and it were to leak out, our bit would change
value, which is an error. By using lots of electrons,
we're OK if a few leak out. DRAM circuits periodically
check the logical level and replenish missing electrons. Encoding one logical bit in the
state of so many physical bits gives classical information
a level of reliability that we take for granted. We don't have to think about all
those electrons bumping around when we write our programs. OK, so why can't we
just put our DRAM into a quantum
superposition of 0 and 1? Well, suppose we did
have that superposition. It wouldn't last long. As soon as we do the first
check to protect against a DRAM error, we've forced the
bit into either 0 or 1, removing the quantum
superposition state. In fact, that
collapse happens even without us checking for errors. A single photon interacting
with just one of our electrons can carry off information. When that happens,
it's as if the photon observed the quantum state
and the state collapses. You can think of this as nature
observing and thus destroying our quantum states. Errors like this are unique
to quantum information. In classical computing,
you might be upset if somebody peeks at your
bits, but that peek doesn't completely destroy them. Note that an error occurs
whenever nature observes any one of our physical
bits, so while we normally stack up more physical
bits for redundancy, that approach actually
makes quantum errors worse. That's the main difficulty
in quantum computation-- the fundamental quantum
constituents of matter are small and easily
subjected to noise, but we can't brute force
our way around that noise with redundancy because
bigger systems are more subject to quantum errors. At Google, we use
a technique that gets the best of both worlds. We use circuits with a
huge number of electrons, but we prevent quantum errors
with superconductivity. In regular metals, like with
a conventional DRAM circuit, every individual electron
does its own thing. As electrons move around,
they can bounce off the positively charged
ions of the metal, radiating vibrational waves that
carry off quantum information about the electrons. This hectic, bustling cauldron
of physical interactions generates a lot
of quantum errors, and the information gets
lost before we can use it. However, when certain
metals are cooled down, their electrons join
together in a single unit. The individual electrons
no longer scatter and the rate of quantum
errors drops to almost 0. Our quantum bits are, in fact,
just electoral oscillators built from aluminum,
which become superconducting when cooled
to below 1 degree Kelvin. The oscillators store tiny
amounts of electrical energy. When the oscillator is in
the 0 state, it has 0 energy. When it's in the 1 state, it
has a single quantum of energy. The two states of the oscillator
with 0 or 1 quantum of energy are the logical states
of our quantum bit, or qubit for short. Here's a picture of a
superconducting qubit along with a circuit diagram. The crosses indicate
Josephson tunnel junctions, which are nonlinear
superconducting inductors. We pick the resonance
frequency of our oscillators to be about 6 gigahertz, which
sets the energy difference between the 0 and 1 states. That's a low enough
frequency that we can build control electronics
from readily available commercial parts,
but also high enough that the ambient
thermal energy doesn't scramble the oscillation
and introduce errors. 6 gigahertz corresponds
to 300 millikelvin. Fortunately, refrigerators
that get to 15 millikelvin are relatively standard
commercial products. For comparison, outer
space is about 2.5 Kelvin. I think it's cool that
the cryostats in our lab are colder than deep space. Now let's take a minute to
make a few comments on how superconducting qubit
architecture differs from conventional computers. In a conventional computer,
memory and logic processing are separated into
the RAM and CPU. When we want to
do a computation, we first move the data
from the RAM to the CPU. Then the circuits in the
CPU do the computation, and finally, the resulting
data is written back to RAM. In quantum computing, with
superconducting qubits, we can't afford the
errors that would come from moving the data around. Instead, we build a grid of
qubits, each one connected to its neighbors. The qubits stay put and
we do logic operations by sending control signals
into individual qubits or pairs of qubits. Now that you have a basic
picture of superconducting qubits, let's take a look
at one of the challenges that we're still working on. Superconductivity
greatly reduces errors, but there are still some. For example, the electrons
flowing in the oscillator interact with charged
particles in the surroundings, leading to errors. Suppose there were a charged ion
inside the metal of our qubit. The oscillating
energy in the qubit can transfer into that ion,
causing the qubit's logic state to flip, thus creating an error. Improving the qubit
fabrication process to reduce these
atomic imperfections is a big part of our research. Over the last several
years, improvements in microfabrication
techniques have decreased our qubit
error rates a lot, and we're still improving. In this video, we
focused on the idea that information is physical. We discussed the
physical incarnation of classical and
quantum computer bits. We introduced quantum
errors and explained why we need superconductivity
to eliminate those errors. If you'd like to know more,
you can leave questions in the comments section below. It's important to me
that you can understand the physical aspects
of quantum computation as clearly as possible. I'm also pretty active on
Physics Stack Exchange. You can find great questions
and answers there, too.
