that stores and acts on information in its quantum

form.

Today, we are entering into an exciting era

where quantum computers are beginning

to be large enough and performant enough

to execute tasks in less than a second that

would take years to execute on a normal computer.

Here is Google's own Bristlecone chip.

This is a quantum computer made of superconducting circuits

with 72 quantum bits.

Google's researchers are using this chip to attempt to achieve

a task that cannot be solved in years on a supercomputer.

Hi.

I'm Dave Bacon from Google.

I run the team that builds software for Google's quantum

computers.

And today, I'd like to tell you a little bit about how

we program Google's quantum computers.

We do this using an open source framework called Cirq.

A quantum computer stores its information using quantum bits,

or qubits.

The information in these qubits is then

maneuvered around using the laws of quantum physics.

To describe an algorithm on a quantum computer,

you would use what is called the quantum circuit model.

The quantum circuit model is essentially

a diagram describing how to perform a quantum computation.

Here is an example of a quantum circuit.

You read this diagram like a sheet of music

from left to right.

Each of the qubits in a quantum computer

corresponds to a single horizontal wire

in the quantum circuit.

Here we see that this quantum circuit

operates on four qubits.

The boxes in the diagram correspond

to quantum gates that are applied to one or more qubits,

depending on how many wires the box is connected to.

Here's a single qubit gate.

And here is a two qubit gate.

Quantum gates are instructions to send control signals

to the quantum computer to perform a certain quantum

action on the qubits.

Finally, one has instructions for reading out

the quantum information.

This corresponds to quantum gates that perform measurements

and turn quantum bits into classical bits.

If we have a quantum circuit diagram,

we can use this diagram to send microwave pulses

and instructions to our quantum computing hardware

to execute the quantum gates, and then

read out the result of the circuit,

like reading a sheet of music.

As we sweep from left to right, we play the given gates

as they appear.

The quantum circuit diagram is cool looking.

But of course, if we had to draw a diagram to do this,

and we are writing really long quantum programs,

this would quickly become very challenging to do.

To solve this problem, researchers

have developed frameworks, or programming languages,

to write more traditional looking programs that

represent the quantum circuit.

An open source framework that we use at Google for this effort

is called Cirq.

Welcome to the [? Cirqus. ?] Let's write a simple circuit.

Cirq is a Python framework.

This means you can use all the goodness of Python

in helping to write your quantum program.

The central object in Cirq is a circuit object.

Here we show creating a circuit object.

Another key set of objects are qubits.

Let's define two qubits with simple names.

Now we can perform some quantum gates on these qubits.

Let's apply a single qubit Hadamard gate denoted by H

to one of the qubits, followed by a two qubit controlled

NOT, or CNOT gate, between the qubits.

Finally, let's measure the quantum bits.

What circuit have we produced?

Simply use Print to see the circuit.

No, it's not 1993.

But ASCII diagrams are useful for seeing the quantum circuit

that you've built. Here we see the H gate for a Hadamard,

followed by the controlled NOT gate with the ampersand symbol

and the x symbol.

And finally, the measurements represented by M.

Once we've constructed a quantum circuit, what do we do with it?

In Cirq right now, you can perform

a simulation of the circuit.

Here we run the circuit 10 times and see the measurement

results.

Measurement results in quantum computers

don't always give the same values of bits.

One run of the circuit may result in the output being 0,

and another in it being 1.

Here we see that the measurement results differ

for each run of the simulation.

Cirq also contains an interface for running the quantum circuit

against actual quantum hardware.

Now that you've seen a simple quantum circuit in Cirq,

you might think, great.

Now I can write really large quantum programs.

For example, it is known that quantum computers can

efficiently factor numbers, something that breaks

modern public key cryptography.

That's pretty scary.

Today's quantum computers, however,

are very far from being able to perform this task.

This is because essentially, quantum computers can only

perform so much quantum computation before the quantum

computation falls apart.

Consider again a quantum circuit.

Every gate that you apply in this circuit

corresponds to some pretty complicated electronics,

shaping and setting of electromagnetic fields

to the quantum computer.

These pulses are not always perfect,

and so every single one of the gates you perform

has some effective chance of failing.

Boom!

One of our single qubit gates has failed.

In addition to not being able to execute gates exactly,

quantum computers also have a problem just doing nothing.

That is, if you leave quantum bits around, over time,

the quantum information stored in them will decay away.

We call this process decoherence.

Boom!

While waiting to execute the next gate, one of our qubits

has failed due to decoherence.

Today's quantum computers don't perform exactly

as we specify them in the quantum circuit model.

We call this the problem of noise in quantum computers.

Because of noise, the size of our quantum computation

is limited for today's quantum computers.

It is limited both in the number of qubits

and the number of operations we can perform on these qubits.

If quantum computers are noisy, can we ever

build a really large quantum computer?

The answer to this is yes.

Using a magic protocol called quantum error correction.

We won't focus on error correction here,

but it is a procedure for turning a bunch of noisy qubits

into a fewer number of much less noisy qubits.

Since today's quantum computers cannot perform arbitrary large

or long quantum computation, an important question is,

what can they do?

This is the main question of what people call the NISQ era.

NISQ stands for Noisy Intermediate-Scale Quantum.

And it is used to distinguish today's quantum computers

from future error corrected quantum computers.

Are there algorithms of practical value

in the NISQ era?

We do not know the answer to this question.

On the other hand, we also know that we

are starting to build quantum computers which

exceed the capabilities of classical computers,

the so-called supremacy frontier.

Because of this, there is tremendous excitement

in quantum computing.

We are entering into the unknown,

an era where there is potential for important discovery.

We built Cirq for NISQ computers and to aid in this discovery.

Because Cirq is focused on NISQ computers

and not on quantum error corrected computers,

we made some choices that we believe

are important for these near-term devices.

As an example, one choice we made

is that we believe that the programmer who

is coding for NISQ algorithms needs

to be very aware of the idiosyncrasies of the hardware

upon which the quantum computation is run.

Hardware is not abstracted away in Cirq.

In Cirq, this is captured by device objects.

Here is the device object for our Bristlecone device.

Printed out, it gives a representation

of the layout of the qubits on the device.

We see that it is a strange grid of qubits.

The qubits are represented by pluses.

The lines between the qubits represents the fact

that only adjacent qubits can be subjected to a two qubit gate.

For example, we can perform a two qubit

gate between these qubits, but not

these, which are too far apart to directly interact.

Another subtlety of the Bristlecone device

is that there are important constraints

on when you can simultaneously perform two qubit gates.

If you apply a two qubit gate to two adjacent qubits,

then you cannot simultaneously apply a two qubit gate to any

of the adjacent qubits of this two qubit gate.

Because the hardware isn't abstracted away in Cirq,

we can use the device objects directly

when building our quantum program

to enforce these constraints.

For example, here we try to perform two two-qubit z gates

at the same time on adjacent qubits.

But because we had passed in the device object to the circuit,

it is aware of the Bristlecone constraint.

And when we print out the circuit,

we see that the circuit has correctly moved one of the cz's

to a later time slice in order to avoid

violating the constraint.

Cirq is an open source project license

under the Apache 2 license.

If you want to install the latest release of Cirq,

you can simply run "pip install cirq"

in most properly configured environments

for running Python.

Cirq is an alpha release.

That is, it is under constant and active change.

We welcome contributions.

To do this, you can go to Cirq's GitHub repo,

and follow the instructions for contributing.

The GitHub repo also contains links

to further documentation for Cirq.

I'm excited by the next few years of quantum computers.

Are there NISQ algorithms that can perform problems

of practical importance?

Cirq is a tool we are using to help

explore this exciting question.

We hope that you've enjoyed this brief introduction

to programming a NISQ computer.

For more information about Google's efforts in quantum

computing, I encourage you to check out

Google's Quantum page.