KEVIN SATZINGER: Thank you.

My name is Kevin Satzinger, and I'm here

today to share with you our latest

results on Quantum Supremacy: Benchmarking the Sycamore

Processor.

The promise of quantum computing is

that it can solve certain useful problems that

are simply beyond the reach of classical computing.

And most of those applications are here

in the useful error corrected machine,

which is still years of research in the future.

But we also hope that in the near term, in this blue region,

we will be able to find useful applications.

But, of course, before a quantum computer

can do something useful that is intractable for classical

computing, it must first do anything

at all that is intractable for a classical computer.

And so a real question that has been on our minds

in this whole industry for the last decade is,

can we cross this line?

And this is something that our group has been focusing on

for the past several years.

It's something that was given a name by John Preskill in 2012.

He called it quantum supremacy, to perform tasks

with controlled quantum systems going

beyond what can be accomplished with ordinary digital

computers.

He went on to ask, is controlling large-scale quantum

systems merely really, really hard

or is it ridiculously hard?

Well, I am pleased to say that it is merely really,

really hard.

And we demonstrated this with the paper

that we published last fall where we showed crossing

this line for the first time.

And looking at this slide, I see there's

a lot of words on there.

So maybe a picture would be a better way to reflect this.

And I want to emphasize that this is a huge team effort.

And I'm very thankful to each and every person, each

and every member of this team who contributed to this work.

And I'm honored to be here today representing them.

You can find our paper on Nature.

It's open access.

And also at this archive link, we

have updated versions of our supplementary information.

At the centerpiece of this paper was a new processor

called Sycamore.

And it's positioned here right at this boundary

between classically simulatable and

beyond classically simulatable.

And that's what I'm going to be presenting about today.

First, the march from graduate school in the upper

left toward industrial technology that

can take on a supercomputer.

And then how that plays into this research

direction towards useful error corrected machine.

For there is this talk, I'll be following this outline.

So we'll look first at the Sycamore processor.

Second, how to calibrate and benchmark Sycamore.

And finally, quantum supremacy itself.

So let's get started with Sycamore.

And before we get to Sycamore, I want

to flash back a few years to what the state of the art

was in 2015.

This is a chip from the Santa Barbara group.

It's about a centimeter in size.

And it has nine transmon qubits in a linear array.

And what I'd like you to observe is

that the control wiring takes up about half

of the area of this chip.

And when you look at this device,

it is not at all obvious how we could scale it up

to a two-dimensional array with 50-plus qubits.

It's not a matter of copy/paste.

We need to really re-engineer the system in order

to make it scalable.

And one of the key technologies that

made it possible to make such a two-dimensional array

was moving to a scalable flip-chip design, where we

have two chips instead of one.

So one chip, this top chip, will be solely responsible

for a two-dimensional array of qubits.

And the other chip will take care of all the readout and all

the control wiring.

And by dividing the responsibilities like this,

we'll be able to have a more scalable design.

One of the key technologies that makes this possible

is these indium bumps, which provide a superconducting

interconnect and a mechanical connection between the two

chips.

This is a photograph showing a small processor

prototype that demonstrated this flip-chip technology.

So there are four chips in this photograph.

At the bottom is a qubit chip that has a small 2 by 3

array of superconducting qubits in the center.

And the rest of the chip is just covered in those indium bumps.

In the center is a separate chip that's

responsible for readout and control

and interfacing with the outside world.

And what we do is we take the qubit chip

and flip it over on top of the control chip,

align them, and press them together.

And that completed assembly is what's

at the top of the photograph, where we have two chips stacked

together and ready to use.

Now, this is how you can make a quantum processor.

But one of the lessons that I want

to share with you is that there's a lot of hardware

infrastructure that goes into making one of these experiments

actually work.

So let me share with you a couple of highlights.

One is packaging.

This is basically anything that goes

between the quantum processor and our dilution refrigerator.

And in our case, we have the processor

embedded in a circuit board with superconducting metal.

And the circuit board interfaces with about 150

coaxial connectors around the perimeter.

We also encase the processor an electromagnetic

shielding to protect it from the outside world.

We then take this package and bolt it

to the bottom of a dilution refrigerator, which

will cool it down to about 10 millikelvin

and also is responsible for delivering signals

through a couple hundred coaxial cables

that go from room temperature down into the device.

Another key piece of hardware infrastructure

to get these experiments to work is our electronics.

These are room temperature electronics

that generate the control signals for our processors.

And we use custom scalable electronics.

Here's an example of one of our boards.

In the center, is a field programmable gate

array that's responsible for driving eight

digital-to-analog converters circled

around it, which then drive these eight channels.

These can output arbitrary waveforms from 0

to 400 megahertz.

And we can also up-convert those with mixer

to microwave frequencies like around 6 gigahertz.

This is just one card.

We can have many of these cards in a crate, like depicted here.

And then several of these crates in racks working together

in concert to control one of our processors.

Now I'd like to turn to Sycamore itself.

One of the key advances of Sycamore

is that it's a new tunable coupling architecture.

This is a new feature where we're

able to turn the qubit interactions on

and off at will.

So the qubits can be independent of each other most of the time.

But then when we want them to interact and get entanglement,

we can turn on the coupling for a brief period of time.

This, it turns out, was immensely

helpful to making the full system work

and was really a key breakthrough

in order to get this processor to perform.

We did this with a scalable two-dimensional architecture,

where we introduce an extra coupler

transmon between each pair of qubits where qubit itself

is also a transmon.

And this is depicted in this device schematic

here, where we have 54 qubits and 88 couplers,

one between each pair of qubits.

I want to share with you a little bit of data showing

how these couplers really work.

So let's look at a simple experiment

where we have two qubits next to each other

at the same frequency.

What we're going to do is excite one qubit

and then have the two qubits interact for a period of time,

the vertical axis, subject to a certain coupler

bias, the horizontal axis.

And let's look at the center first.

So, in the center here, the coupler

is at its maximum frequency.

And so there is a few megahertz of coupling between the two

qubits.

And what happens is this photon leisurely swaps back and forth

between the two qubits.

That's what these oscillations are.

But as we march to the right, as the couplers' frequency comes

down, there is this divergence where

there is no more swapping.

This is where the coupling is turned off

and the two qubits can act independently.

This is a very valuable place.

This is where we operate ordinarily.

But sometimes you want the qubits to interact.

And to do that, we'll post the coupler a little bit further

to the right so that we have very strong coupling

for a brief period of time between the two qubits.

I'll end this section with this nice photograph of our Sycamore

processor.

And a nice symmetry that I could highlight

is that the center chip here with the qubits

is about a centimeter in size, which

is the same size of the chip we looked

at the beginning of this section.

So now let's move on to calibration and benchmarking.

Suppose that I handed you all of these electronics-- the fridge

and cables, the packaging and the processor.

It is not a trivial matter to turn all of that stuff

into a quantum computer.

And calibration is the process of learning

how to execute quantum logic with our hardware

so that we can go from all of our stuff

to a system that can run an arbitrary quantum

algorithm in the same way that you could play music

on a finely tuned piano.

But this is not a trivial task.

There are around 100 parameters for each qubit.

We need to choose a frequency for every qubit and coupler.

And there are strong interactions

between those frequencies and biases.

And then we need to tune up all of the gates

and readout for each qubit and pair of qubits.

Now, if you have just a few qubits,

you can park a graduate student in front

of a computer for a couple of days,

and they'll be able to work it out.

But if you have 5o-plus qubits, you

need a much more scalable solution.

And in order to solve this problem,

we encode our calibration routines into a graph.

And this allows us to solve the problem using standard graph

traversal algorithms.

Pictured here is an example calibration sequence

for two qubits.

And this network is really a graph

distilling decades of research from groups

all around the world learning how

to make these processors work.

In this graph, each node represents

a physics experiment, where we acquired data, and then

the analysis that we use in order

to figure out what the data says and decide what to do next.

This is an example for two qubits,

but there are literally thousands of these nodes

when we want to calibrate Sycamore.

So it's crucial that we use algorithms

to work through this graph, to calibrate the device,

and then maintain the calibrations.

To give a flavor of how this works,

we start on the left learning some device parameters.

And as we work to the right, we iterate back and forth

between single-qubit gates and readout