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.