SPEAKER 1: OK, so while people are coming in the first few minutes I'm going to introduce this lecture series and also the speaker. This is the third of three Bethe Lectures to be given by John Martinis, Professor at University of California Santa Barbara. And this is the lecture intended for the general public, which means in particular that there will be a reception in the PSB atrium just outside the physics department with free food, but you have to stay until the end of the talk.
So Hans Bethe, who lived from 1906 to 2005, was a giant of 20th century physics. He was already retired when I arrived here as a graduate student in the late 1970s, but but happily, he remained a fixture in Neumann Lab where that part of the Department worked, and I was able to interact with him occasionally.
He was born in Strasburg, Germany, in 1906, started as a chemistry student, but ultimately moved on to physics, where he completed his doctorate at Munich with Arnold Sommerfeld in 1928. This time frame put him among the first of the young physicists to explore the applications of the then new quantum theory, which as you'll see from the talk to come, makes him a fitting-- it makes the Bethe Lectures a fitting platform for the lectures that we've been having on quantum information and quantum computing.
At age 24, he wrote a classic article on spectroscopy, one of the first applications of group theory in quantum mechanics. He later took a position as Assistant Professor at the University of Tubingen, but was fired due to a government edict because he had Jewish ancestry. And reading the writing on the wall, he left Germany for good in 1933. He was recruited to Cornell in 1935 for a salary of $3,000 per year, and that put the physics department at Cornell on the map. Within a few years of then, he explained how stars burn hydrogen to helium, in effect, creating the field of nuclear astrophysics, for which she won the Nobel Prize in 1967.
He took a few years of leave from Cornell during World War II to be the head of the theoretical physics division at Los Alamos, where they created the first atomic bomb. He reported to Oppenheimer and later testified in his defense. Feynman, who reported to Bethe there, described him in one of his books, and let me make sure I get this accurate, described him as, quote, "a battleship surrounded by an escort of smaller vessels," referring to the younger theorist, "moving majestically forward through the ocean of the unknown."
In 1947, after he returned from there, he did what is the envy of every young theorist, even though he was no longer all that young. He learned at a conference called the Shelter Island Conference in 1947 about a very mysterious energy difference between the two lowest states of the hydrogen atom, the so-called Lamb shift. And on the train back to upstate New York, he was able to calculate this difference using what we now call mass renormalization, so effectively paved the way for the revolution in quantum electrodynamics. I saw an interview he gave. He calculated this-- an interview he gave somewhat afterwards and he said, the first thing he did after getting off the train was to go to the library because he wasn't sure that he hadn't remembered the fundamental constants correctly and thought he might have been off by a factor of 2, but he got it on the nose.
Following World War II, he was one of the founders of the Federation of Atomic Scientists, played a leading role in the public debate about nuclear weapons defense policy and nuclear power, was an advisor to several US presidents on national security policy, opposed the development of the hydrogen bomb. And his work on arms control helped lead to the limited test ban treaty of 1963.
He retired from Cornell in the mid-70s after 40 years on the physics faculty, but the informal collegial environment that he fostered here remained one of his legacies. And he also kept working. In 1986, at the age of 80, he helped solve the solar neutrino problem that had mystified stellar astronomers for 20 years.
He wrote a major article during every decade of his over 70 year career, including an article during his 90s about supernova explosion. So every decade of his career, essentially, would have been the envy of any other scientist. He passed away in 2005 at the age of 98.
So today's speaker is John Martinis, as I mentioned, currently at UCSB. He received his Bachelor's and PhD degrees from the University of California in 1980 and 1986. His thesis was a pioneering work on what we now call qubit states in superconductors. This was before the word qubit was even coined in the early 1990s. So in this sense, he's been working in this field as long as anyone.
He moved after his doctorate to work as a postdoc at CA Saclay, outside of Paris, and then the US National Institute of Standards and Technology in Boulder, where he developed a new fundamental electrical standard based on counting electrons and invented microcalorimeters based on superconducting sensors.
2004, he moved to University of California Santa Barbara, where he currently holds the Worcester Chair in Experimental Physics, and where he also has continued working with Josephson junction qubits with the aim of building the first quantum computer. In 2014, his team was hired by Google to continue this work, and in 2019, he was the lead author on the highly publicized quantum supremacy experiment. In 2020, he told us last night at dinner, he had the brilliant idea to spend nine months in Australia, where the COVID rate was 0.
He has received a number of prizes, including the London Prize in Low Temperature Physics in 2014 for his work on quantum control quantum information processing, and the John Stewart Bell Prize in 2021 for research on fundamental issues in quantum mechanics and their applications.
So ordinarily, I like to tell personal anecdotes about my longstanding association with the speaker, but I met tonight's speaker for the very first time just two days ago, and the only memorable anecdote from dinner last night was that he couldn't remember the year of his PhD. On the other hand, I can relate that eight years ago I cold emailed him-- I don't know if you remember this, John.
JOHN MARTINIS: When?
SPEAKER 1: Eight years ago.
JOHN MARTINIS: Oh, OK. No, I don't remember.
SPEAKER 1: I knew you couldn't remember what, 1986, but 2014, I thought it might be possible.
Anyway, I had a question about a talk that he gave that I was referring the students in my course to and also about a review article that he'd written on quantum error correction. And I got a very genial response back that very same afternoon-- I don't think this will be embarrassing at all-- both with the answer to my question and some additional informative information. He said he was happy I was using the review article, and then he said, regarding the quantum error correction, I'll just quote it here-- "what I really like about the surface code is that it is simple enough to get a really good understanding of how to put the entire computer together. This had a big effect on my research program, since I then knew what to fix to try to build a real quantum computer." And that's what is going to tell us about tonight, so let us welcome John.
JOHN MARTINIS: Yeah, thank you. I appreciated that story.
Yeah, it's a real honor to be here and to be in the lecture series after a very great physicist, whom I actually was able to hear lecture in my career, I remember, in Colorado one time doing that. And people have been really nice here, great conversations, and it's just really fun to talk about this.
People, physicists have been thinking about a new way to manipulate, store, manipulate information based on quantum mechanics. And it kind of got first thought about in the 1980s and got very serious in the 1990s. And so it's been many decades, quite a few decades now that people have been wanting to manipulate, store, manipulate information in this very powerful way. And I and many other people have been working for a long time to try to make this happen.
And things have been progressing very well. And in 2012 or so, I got a call from Google to think about and then gave a talk and then join their group to basically help build a quantum computer, something I wanted to do and something they were interested in doing. And we thought-- I thought going there would be good because they have the resources to do this.
One of the interesting things that I found out a few months after I was in Google was the idea that some of the people in Google thought it was really kind of crazy that Google was trying to build a quantum computer. And these are people who built the gigantic Google data centers to manipulate information for Google. They're huge. It's kind of hard to imagine how big these are.
And how can we with this little physics experiment do something that might compete with this gigantic data center? And they thought it was just absolutely crazy that we're doing it. But we were a small group, and we tried to stay under the radar and do something.
And then after a few years there, the theorists came up with an idea to actually show-- in a small time frame, to show that a quantum computer was powerful. It wasn't going to be useful yet. It was going to run an esoteric algorithm, and I'll talk about that. But it was really showing that it was very powerful. And in fact, what we did with the quantum computer is we took data for about 200 seconds, and in order to check that data, you had to run it on a gigantic Google data center, if we could, for thousands and thousands of years.
And what was great is this was an experiment that kind of showed the Google executives that indeed you can build a powerful processing machine. And in the end, that was the way that the group got more money to build, hire more people, and to do it very seriously.
So today, I want to talk about what is a quantum computer and kind of show you what that experiment was. And I think it's been really good for the field to show that you can build a powerful quantum computer for some kind of mathematical problem. And of course, what we want to do next is to build something useful. And that's going to take some time. I'll talk a little bit about that.
Now, given that this is for a general audience, I thought I would first try to explain quantum mechanics to you, but OK, at least in a simple-minded way. And I'm going to use a friend of ours and his drums as an example to help do this.
So this is a picture of a very famous drummer. Do people know who that is? He's actually an alumni of Cornell, a professor. He was a professor at Cornell. He got recruited by Hans Bethe, and he helped found the field of quantum information. And of course, it's Richard Feynman. He was very famous for playing the drums, but I'll get to that in a second. OK.
So understand, quantum mechanics, quantum mechanics is very important for us. Otherwise, all matter around us, we would have no size. So the size of atoms, of matter, whatever, is determined, is set by the laws of quantum mechanics. And it's very important. It's one of the beautiful things we do that. And basically, what happens is in the quantum systems, you have here hydrogen, you have a proton and an electron.
And if it were classical, the electron and proton would attract each other and stick together and an atom would have no size. But instead, because of quantum mechanics, there's this cloud of the electron around the hydrogen atom and that gives it size. And that is described by quantum physics.
Now, being a physicist, of course when my two boys were young, I had to explain what I was doing. So I have to explain to 5 or 10-year-olds what quantum mechanics. So I would tell them the way the atoms work is that the electrons are fuzzy, OK, and they kind of form this cloud around it and you have size, whatever. But they were pretty smart, and they never bought that at all. They just thought that that was totally ridiculous. So I thought that was pretty good for them.
So let's get a little bit more sophisticated. And what's interesting about quantum mechanics is there's uncertainty to the electron that forms this cloud, but it's actually forming a wave around the proton. And these waves can be thought, at least in an approximate sense, but it's not so bad analogy of the different kinds of oscillation modes you would have on this drum right here. And in this particular, you have an oscillating mode where the drum is going up and down, and then you have this mode here when the outside is going down and the inside is going up. And then you have these other kind of modes and where it's going up and down like this.
And if you actually solve the quantum mechanics of this, these electrons are waves, OK, and it's a standing wave around the proton. And it actually have shapes given by this. So you see this lower energy, which is called the S state, OK, that has a wave nature that kind of looks like this fundamental mode of the drum here. And then there's also some oscillating modes that are higher energy, higher frequency, if you like, higher tone. And in this particular case, this kind of mode here is called a 2s state, looks like this. And this particular mode here is a 2p state and kind of looks like this. And they're a little bit different shapes, but the basic idea is the same.
So we have these different kind of modes that it wants to oscillate in. And what we do in a quantum computer is we take advantage of this wave nature of the electron and say that this 0 state is going to be this ground state, this kind of mode here, and the 1 state we're going to encode into, in fact, this state here, which looks like this. And that way, we're going to call those states 0 and 1, and then we're going to start manipulating data according to these quantum states. And then you can build, for example, as an example out of a hydrogen atom in this way.
So these are-- it's kind of funny to build these classical states, or these states this way. You know, normally in a classical computer like this, you would have a state where it's like 0 volts is 0 and 1 volt is a 1, and here we're just encoding it in a different way. But you can still store and manipulate information that way.
Now, I want to explain a little bit why you would actually go ahead and do information this way. And what happens is because these are ways in the quantum system you can actually put them in what's called a quantum superposition, where you have this oscillating drum, if you like, in the 0 state, like this, and the 1 state at the same time. So it's just some complicated oscillation of both of those. And if you take, for example, the case where they're equal weight of 0 and 1, you can put it into this very strange state.
Now classically, if you're going to do a calculation, you do a calculation of zeros and ones, and it's either 0 and you run that through your computer, or a 1, and you run that through computer, or a string of zeros and ones, but it can only be one or the other. In a quantum computer, it can be both 0 and 1 at the same time. And you can take that weird quantum state and run it through a quantum computer and then to get an answer out in the end.
Now, why is this interesting? It's because you're basically doing a parallel computation of both 0 and 1 at the same time, running it through your quantum computer. And that parallelization gives you a speed up, let's say, of a factor of 2, because you're trying both cases, 0 and 1, at the same time.
So that's nice. It sounds very academic and OK, great. But what's really interesting is what happens when you use more than one quantum state. So let's say you have two and you put each one in the 0 and 1, and you can think of that, it's equivalent to taking the four states, 0-0, 0-1, 1-0, and 1-1, and running it through your computer at the same time. So for one qubits it's two states. For two qubits, it's four states. You can do the same calculation for three qubits, and that's eight states. Four is 16. 5 is 32.
So every qubit you add, you double the amount of parallel computation you do. And this is very different than classical computing, where, let's say you get a new processor and it's twice as fast-- 2 gigahertz instead of 1 gigahertz, then you have twice the computation. But in here, every time you add a quantum bit, you double it.
So that makes it huge-- exponentially large when you get to a lot of qubits. So for example, by the time you get to 50 qubits-- which is what we've done for this experiment, more or less-- 2 the 50th is many trillions of states. And that's going to tax a supercomputer. And if one day we buy-- we build a quantum computer with 300 qubits, 2 to the 300 is a number greater than the number of atoms in the universe. And clearly, we can do some calculation there that you can never do on a classical computer.
Now, there's one caveat to that. In quantum mechanics, you do all this calculation and the like, but in the end, you have to measure it. And when you measure it, you only get 50 bits of information or 300 bits of information. There's kind of this collapse of information.
And what that means is you can only run certain algorithms that can take advantage of this parallel computation, not, you can't just take any algorithm that you have right now on your phone and run it, and it's going to be better. You have to do special algorithms.
But we'll come to that at the end. There are some algorithms that is interesting. But it does mean that there's a challenge to figure out how to build it properly-- how to build algorithms properly to take advantage of this.
OK, so my job is to actually build a quantum computer. So let's talk a little bit about how you go about thinking about using the computer. And I'm going to use an example that we do on classical qubit-- classical bits, say, CMOS. So this is how your phone is working.
And in this phone, you have a bunch of transistors for forming logic gates. So this logic gate here with two inputs and one output is called an AND. And you have to have a 1 and 1 in order for 1 to get out here. Any other combination, you have a 0.
And this is an OR gate where, if you have a 1 or a 1 or both 1's here, then you'll get a 1 coming out of that. So these are logic gates. And by, basically, putting them together properly, you can do things like, in this particular case, it'll add two numbers with a carry in that'll give you a sum and a carry out. And through just this logic and much more logic, then you can build adders and multipliers that you have in your CPU. And that's the way you think about logic.
In quantum bits, it's a little bit similar to that, but there are some differences. And first of all, you have your quantum bits. And they are running on individual hardware-- quantum bits, hardware. And then, what you do is instead of wiring up and having the signals go through these gates left to right in time, what you do is you apply these kind of gates to the qubits over time.
So this is a single-qubit gate operation on one qubit with the one box. When these are two are connected, there's some kind of interaction between the two qubits-- kind of like these kind of interactions here-- that does some logic form. And instead of building these kind of logic circuits, you build these kind of logic circuits.
And what happens is you take your qubits, and then in units of time, you run an instruction set. So this is an instruction set 1 where you're doing something to all the qubits. And an instruction 2, you're doing some other operations. And in instruction 3, you're doing another operations.
And this is basically kind of how a regular computer works where you programmed with instructions. But here, you're actually doing it on the very basic qubit operation. That's what you have to do. But it kind of looks like this.
And then, you build up your circuit. And in the end, you do the measurements of your quantum bits, and you get some answer out of it. And we'll talk about that later. OK, so that's kind of how the basic quantum computer works.
Now, what I want to tell you about is getting a little bit more subtle and talk about the errors of the qubits. And I want to motivate this with the following case, which might be interesting for the general audience. So you're interested in, maybe, quantum computing. It's the next best thing. And maybe you want to be an investor in quantum computing.
And what I want to do here is give you a little bit more information what's going on here so that you can see which of the companies might be working well or not and what's really going to matter to build a quantum computer. And of course, you should never take investment advice from a physicist, OK? You know that.
But I will try to explain this in a way that you can understand. And then, we're going to look at some data, and then you can understand where the field is and what we have to do. OK, hopefully this is good. So the first thing they have to do is talk about errors in the quantum computer. And in fact, it matters. It fundamentally matters.
Now, what I'm going to do is talk about classical bits, thinking about that as a, let's say, a coin on a table. And I'm sure no one has a coin in their pocket, so let's talk about a cell phone. And we can talk about the cell phone up being a 0 and a cell phone down being a 1. And we can make a computer out of coins on a table.
Now, the nice thing about classical information when you encode the data this way is when I put this down in one of the states-- say, a 0-- this is a stable state. We can jiggle the table a little bit. This may bounce up and down a little bit. But it takes energy for this to flip over.
And before it gets too much energy, it's going to fall back to the table. There's some dissipation, whatever, and it'll just sit on the table. So this is very stable. The classical bits can be fundamentally stable.
However, in quantum bits, it's a little bit different. And we can treat of this as something called a Bloch vector. Where the Bloch vector is pointing in space. So think of the phone, and there's pointing in space. And this would be 0, and this would be 1. But it also turns out that the 0 plus 1 state I was talking about is actually rotated 90 degrees.
And you can have mostly 0, but a little bit of 1, more and more 1, and then, mostly 1. But it's continuous in how it can operate this way. And there's also another phase that's in this direction, too, so it's even more complicated than that.
But the idea here with this analogy-- it's a pretty good analogy to a qubit-- is that if you have it pointing in some direction with your state, if you have a little bit of noise in your system, say, a puff of air to this, it's going to rotate this a little bit. And then, you're going to get an error in the state that you're going to be. So it's kind of fundamentally unstable in this.
And that means when you build your quantum computer, you have to really worry about that a lot. And there's always going to be a little bit of noise that's going to disturb you. So if you go back to the slide I just gave you, well, how do error is affect it? Actually, errors affect it in classical computing, too.
OK, in this particular case, you build a bunch of logic gates, and if you don't build them precisely and there's a piece of dust on the circuit or something, you're going to get an error. And it turns out, when I was young and I was building circuits out of TTL, this had something like 100 or 1,000 transistors in it. And there was a small error of, say, one part in 1,000, that transistor wouldn't work properly. So that once you got to about thousand transistors or so, the chips would stop the work, because most of the time you would have an error. So that told you how big you can make it.
So these were rather modest chips-- a few transistors in it. You put it together, and eventually you would get some gigantic computer filling a room. Of course, nowadays-- what is it, 60 years later-- the errors of which people can make these transistor circuits are way, way lower-- maybe one error in 10 or 100 billion of the transistors. And that way, you can make very powerful processors. Say, your M1 processor in your Apple phone can be made extremely powerful. And you can yield, and it can be economic.
Now, a similar thing happens in a quantum computer that there's errors in this in the same way you can think about this classically. And if you, for example, have 100 qubits here and you run one operation here-- OK, then there's 100 ways to get an error. And that can give you a problem.
Now, the problem right now with all these technologies is that these qubits are error-prone, and they basically have one operation in 100 will give you an error, something like that. Let's just take that as a number. Well, if one operation in 100 gives you an error and you have 100 operations here with 100 qubits, that means you can run a distance instruction set of one instruction set before, on average, it's not going to work.
Now, does that seem very powerful to you? No. You want to run lots of instructions. You want to run a complex algorithm. And in order to do that, you just have to bring the errors down to let's say, 10 to minus 4. And then, and then you can do 100 instructions and it's better.
So this error here is actually quite important to understand in getting this to work right. And in fact, in the quantum supremacy experiment I talked about, we actually worked pretty hard on that. And it's not-- it's a few times 10 to minus 3, but it's enough to actually do something. But that was really important to figure out.
OK, so now comes the investment part of the talk. So people can wake up now. But you have to understand this idea that if you have an error of 1%, you can't do very many instructions, let's say, for 100 qubits. So where does the field stand right now?
So here's a plot of this various errors. This is actually fidelity, which is 1 minus the errors. So the error is the difference between 1% and whatever these bars are showing. And today, in the world around here, there's a lot of hype and some people would say, fake news, so you have to be very careful.
And what I liked about this particular graph by one of the companies here is this was in a deck for a financial disclosure thing. And this data has to be very accurate, or they will get sued by investors and whatever. So this is fairly accurate data of what's going on.
And if you look at the various companies that are making quantum computers right now, you see the errors are in the 2%, 1.5%, 2.5% range. So it's even worse than I was talking about. So if you wanted to build 100-qubit quantum computer, you could maybe run one instruction-- maybe a few instructions it'll work part of the time.
And although these companies have gone public and they've sold shares and they're worth a lot of money, the computers right now-- yeah, can't do too much. And that's fine. They're working on it. Everyone's working on to better, but we really have a way to go.
Now, at Google, we knew about this for a long time. And we've worked very hard on our errors, and we got it down to a fraction-- 0.2%, 0.3%, 0.4%. And thus, we can able to do more complicated algorithms. Still have to make it better, but this really enables us to start doing something with the quantum computer. So that's very important to understand this. And I actually had a lecture earlier on Monday to say how important it was to fix this.
OK, now what I'm going to do is start talking about the system of how we're building these quantum systems. And you can imagine building them out of atoms and molecules, but that's so tiny it's hard to go in there and control them. So what we're doing with these particular cases of superconducting qubits, we're making a quantum system in a totally different way. And in fact, we're making this superconducting qubits out of a system that's macroscopically large. This is almost a millimeter in size-- something you can see with your naked eye.
And what's happening here is this as quantum mechanics being displayed in the currents and voltages in this device. Normally, you think of current and voltages with lots of electrons sloshing around in a metal going back and forth. And what we're seeing and what we've shown in here is that the currents and voltages of this device actually obey quantum mechanics-- have this wave kind of behavior that I was showing before. And thus, you can see the quantum effects in electrical devices.
So this is the device. Most of this is just aluminum on a silicon wafer-- fairly straightforward. And this dark brown is where we've etched it away. These are wires that go into control the qubit. And this is wire, and this resonator structure is how we're going to measure it.
And this is macroscopic, so it's easy to bring in wires to control. It has engineered properties. It's basically an oscillator at about 5 gigahertz frequency. That's more or less a cell phone frequency. So it's a standard electrical technology, and it's built like a computer chip. So once we know how to build one, that's very good. We know how to build many and many of them to do that.
And just to get a little bit more details for the experts. This cross here to here acts like a capacitor. In here, there's these things called Josephson junctions, which are just to crossed aluminum wires with aluminum-- oxidized aluminum on top, and then the electrons can tunnel through there. That looks like an inductor. That forms an oscillator that oscillates at about 5 gigahertz-- cell phone frequencies.
And then, we encode the zero state, just like the hydrogen atom is the lowest energy state. And then, the 1 state is a next excited state, which you can think of oscillating pendulum there. So let's just give you an example of an experiment we would do to show you how it works.
So we take this electrical oscillator, and we just let it sit for some time, let's say, a millisecond, a thousandth of a second. And it'll naturally just decay to the ground state. And then, we'll take a microwave tone-- a microwave pulse of energy that's at the same oscillation frequency of the quantum bit, and we'll inject it into one of those lines that will push this pendulum, this system-- LC oscillator-- back and forth and will excite it and make a transition from the 0 state to the 1 state.
And then, if we keep on doing that, then you're in the 1 state. And you push it harder, it'll go from the 1 state to the 0 state. So after a certain amount of time, we then measure whether it's a 0 or 1 in a quantum mechanical way. And we'll do that about thousand times to get a probability of what you're in the 0 state versus how long you pulsed at for.
And you see that initially, the probability is 1. And then you pulse it for-- what is this? About 10 nanoseconds, it's here. And 20 nanoseconds, it's here. In this state, where the probability of 0 is 0, that's actually putting it into the 1 state. So 20-nanosecond pulse-- we do that. And another 20-nanosecond pulse from here to here takes us back to the 0 state.
And this particular 20 nanosecond pulse we called a NOT operation. It goes 0 to 1 and a 1 to 0. And this is a classical state. It's like taking my cell phone here and flipping it over-- a not operation is 0 to 1. Another operation will take a 1 to 0. So we've just reproduced a classical operation with that.
But of course, besides pulsing it for that amount of time, we can pulse it for maybe 10 nanoseconds. And now, what's happening is this 0 state is now going to this state right here, which is 0 plus 1. And then, if you do another 10 nanoseconds, you'll go to the 1 state. So these microwaves are actually flipping this around like this over time. And that's what these oscillations are representing.
So this is great. It forms a 0 plus 1 state that I said was so interesting and could do the parallel computation. And if a NOT gate and a NOT gate gets you back to the state where you wanted, you can think of this operation here-- operation [INAUDIBLE] NOT-- you can call that an algebraically a square root of not.
Now, OK, what's a square root of NOT? It doesn't make any sense. But it turns out, you go through the operations of the quantum gates, that actually is a well-defined operation. It does that. You can use that in an algorithm to make sense of that. So basically, what quantum computing does is it takes your gates, your operations that you do with a regular calculation, and gives you additional operations to do more complex things and to build up a more complex algorithm to measure the states in the way that you-- operate on the states in the way you want.
So you see, it oscillates back and forth here, really nice-- a bunch of NOT operations here. But you see here, this is pulling off a little bit from the 0. And up here, this is pulling off a little bit from 1. And that has to do with the errors that I was talking about before. And when you operate this, it doesn't quite flip all the way properly.
And you see that this happens over several oscillations here. So it turns out that if you extend this out, you can do something like 500 operations before it stops working very well. So this gives you the error rate-- roughly the error rate is one part in 500 that I was talking about before and tells you how complex of an algorithm you can do. And it's fundamental. It's something we have to work on, but we always have to limit ourselves with that.
So that was our initial device. The device we're making that we'll talk about in this experiment is called the Sycamore Processor, which we made at Google, of course, that has 54 qubits. These little crosses are like the crosses that I showed you in the previous slide which are forming the qubits. And then, between the crosses, we want to be able to couple the two nearest-- the neighbors to the qubits together, and that's with some adjustable switch that we can turn it off to get that coupling on and off.
And this is the chip right here. Basically, this chip has all the qubits on it. And the bottom chip here is where all the wires bringing it out to paths on the outside. And this is what's called bump bonded. They're little, indium islands there that gets pressed together and squished together forming electrical contacts between the two of these. And this chip, it's about that big.
So we make it with standard, clean-room processing, put it together. And then we take that chip-- we have to connect wires to that. And that's shown in this slide right here. We put that in a package, which is basically a big, printed circuit board.
And then, we bring the wire-- we wire bond this to some wires in the circuit board and then out to a bunch of microwave connectors at the end. And then, we take that package and put it inside of this thing called a dilution refrigerator. You can see the package here. And then, we have bundles of these wires going out and wiring up to the top of the refrigerator.
And the one thing to remember when you look at that is you have to be very systematic about connecting the wires properly. So there's a lot of testing and a lot of things we do to make sure we're not screwing that up. We operate this at about-- very low temperatures. Room temperature is 300 Kelvin. Liquid helium is about 3 or 4 Kelvin. This refrigerator gets down to about 0.01 of a Kelvin.
And what happens is the energy-- the thermal energy-- at these very low temperatures is lower than the 5 gigahertz times the energy from the quantum states of 5 gigahertz so that the thermal noise of everything around it doesn't agitate and shake up the qubits and cause them to be in error. So this is-- although you have to go to high temperature, this is a kind of an easy frequency to work with in terms of microwaves. It's something in cell phones, so we can do that.
And then, we take all these wires, and we go up the refrigerator-- again, carefully labeled. And then, we take them out of the refrigerator on this big panel, and we connect them to racks of electronics, which are custom-built D to A waveform generators. And that's how we program it. And there's a tremendous amount of software behind all this to calibrate, and control, and sync everything up.
But to me, it looks something like a small, high-energy physics experiment. So it's something we know how to do-- physicists know how to do. But that takes a lot of work to get all that working right. So at this point, I'm going to soon talk about the data and do a little demo.
I just want to say that since errors are important, we have to measure them carefully. And this is just a slide more for the experts just saying that we measure what the errors are on every qubit. And what we do is we just take a qubit all by itself and do a bunch of these square root of NOT operations and see how the signal degrades in time.
And from that, we get an error, which is typically about 1 error in 500, 600 oscillations or so. And then, we do that on the whole array. And that's this dotted line. This is an integrated histogram. So you see the average value here is at 50%. It's about 0.15%.
And then, to be fair, we're not going to operate the quantum computing one qubit at a time, but we're going to operate them with all the qubits switching at the same time, which is like what's going on in your cell phone. So we turn off all the couplers and do this simultaneously. And then, we get the black line right here, which has shifted a little bit higher error, but it's just a tiny bit. You expect to be some cross talk and little imperfections, but it's not too much. And everything's OK. And then, we also do that when we have the two-qubit coupling.
And that way, we calibrate the system. We know it's working well. We know its errors. And I'll come back to that later, why that's so important. But we can make sure that the system is working right.
Of course, the individual transistors and gates are working right, but what happens when you operate a big, complicated program? Just the fact that the transistors are switching here doesn't mean that when you run all the instructions it'll work properly. You have to test that, too, and that's what we're on to next.
So to talk about what's going on, we have to talk about the program that we ran with it. And this is a two-dimensional array of qubits. And what we do is we run a general-purpose algorithm on this, and I'll talk about the specific sequence we do.
And this is a diagram of all the 53 qubits. One of the qubits here didn't work. And it's looking at what the algorithm does versus time. And when there's a single circle here, like right now, that single circuit represents this square root of NOT operation that I told you earlier that's giving this this 90-degree rotation from 0 to 1.
And you can actually rotate in three-- excuse me-- three different ways. You can rotate this way. You can rotate this way. You can rotate this way. And the different symbols there correspond to that. That's more for the physicists-- you need to know that.
And then, in between that, we have the two-qubit operations, where there's a line in between there. And that's where one of the qubits is interacting with its neighboring qubits and swapping some quantum information with it. And that's part of what you do to make the gates to do an algorithm. And you can see, it's just single qubits-- two qubits-- and it's rotating around.
And then, you can also look at it for-- we just take a central qubit here. And you see the square root of NOT operations, and then it interacts with the neighbor qubit. Another square root of NOT, another qubit, and then it rotates around as to who it's interacting with. And it does this for a bunch of cycles and then measures it at the end.
And that's actually-- that algorithm where it's talking to the neighbors and doing interactions by itself-- is the sequence that you would have for any algorithm you would ever want to do. So it's the fundamental way you think about it. And then, what we do here is a particular algorithm where we do the square root of NOTs here, and then we have these fixed gates between the two.
And that is going to perform an interesting calculation. And let me explain that now. OK, so what does it do?
This particular calculation-- again, we're not trying to do something useful now. We're just trying to check the quantum computer and to show that it's powerful. And it turns out that you can check your quantum computer and show that it's powerful by generating random numbers. Which, OK, it sounds kind of simple. But there's actually something really subtle to generating these random numbers.
So what we do is we have a random number generator with all these sequences here. And when you measure this-- when you generate random numbers-- it's going to mean you get all combinations of the outputs. So you're going to see 000, 001, 010, 011, 100, et cetera-- all those possible combinations.
And normally, if you build this and think about it classically, you think that it's going to be a uniform probability of getting numbers. There's no structure in this algorithm. It's just all chosen randomly, and you would do that.
But what's magic about this-- and because of the quantum system, it's actually not random. And some numbers are going to be a higher probability than some other numbers. And I want to demonstrate that now with something called laser speckle.
And if I can turn off the lights-- and I'm going to turn on this little, green laser over here. And I'll demonstrate laser speckle. And it's going to be a little bit dim, and we might be able to see it.
OK, can you see the side-- kind of this green haze over there? And what's happening here is if you look at the green haze, there are some directions where it's a very bright light and some directions that there's very dim light. It's black and white. It's not a uniform spread of the light, but it's called speckled, where it's bright in some directions and dim in the other.
And what I'm going to do is I'm going to-- this is just a laser beam, which you can see here, that's going through frosted glass that has little bumps in the glass. And that's taking the laser beam and spreading it out. And what's happening here is you have interference of the light in the laser beam.
So the light's coming out, and in some direction, the light from two different areas are coming in. And they're oscillating back and forth together. And when they come to the end, they combine. And it's together, and it's a bigger oscillation.
But in some directions, it's coming out, and the oscillation is in the opposite direction. And then, finally, when it gets the screen, those two oscillations in the opposite direction are adding to 0, and then you get something dark. And the exact pattern of this particular speckle is dependent on the frost that it's going through in this beam.
And if I move this a little bit, you can see that this laser speckle pattern just completely randomizes and changes. Because it's going through different frosting of the glass, it's interfering in a different way. And it turns out-- we can turn on the lights here. So I have here a picture of that, taken from Wikipedia, of course. And you can see, in some directions, the light is very bright. And in some directions, it's very dark. But it kind of represents this spreading beam, in general.
And what happens is we have a similar to laser speckle where some of these output states are going to be bright-- and that means high probability in quantum mechanics language-- and some of these states are going to be dark, and it's very dim, and no light, and low probability. And the brightnesses, dimness is all dependent on the exact sequence of what's going on here.
And just like here when I moved this a little bit and the interference changed completely, it turns out that if you just take one of these gates and change it, then the speckle pattern will completely change, completely randomize. So this pattern that you're getting out of here is uniquely identified with what computer program you ran.
So the way that we check whether the quantum computer is working properly is we go through and we run this through our processor and we get outputs that are going to be, preferentially, the bright outputs, the high probability outputs. The dark states, we're not going to see. And then, what we're going to do is going to take this calibrated thing and run it through a supercomputer. And then, we're going to get all the probabilities. And we're going to check that the probabilities that we measured were actually the high-probability states that we calculated.
And because this system is so big, this is actually a hard calculation. And this has to go through a supercomputer. So we're just checking what we measured against what we expected. And this takes a long time. But if it's big enough, we can do it.
And for the physicists in the audience, if this is totally random, this p is 1 over 2 the N, so this is 1 minus 1 at 0. So if you have one or more errors, it's all random. You don't get any correlation at all.
If you have one or more errors-- if there's no errors at all, you happen to run and there were no errors in that particular run, then this will be a 1, and you'll get a perfect match. And it's really a nice way you can check whether your system is working right and check the full-- you need the full power of quantum mechanics to be able to predict what's going on here. So that's the basic idea-- just checking the quantum computer with this random circuit.
So this is the actual data that we take. So out of this 53-qubit device, we start with 12 qubits, and we run about-- that's about 29 operations through each qubit. And that's about 250 gates in total. And I told you we can run 500, 600 gates before we lose the coherence.
So about half the time, the whole algorithm works. And then, it'll match with this fidelity in one. And then, about half the time it works, half the time it doesn't work, and it averages to about 50% here. But we run the quantum computer, get the data, check it against the computation-- everything works.
And then, as you make it bigger and bigger and add more qubits, there's more possibility for error. And then, of course, it's not going to work so well. And then it goes down, and we see that it doesn't work. And we see the red circles for the full circuit going all the way down here.
And in the beginning, you're checking out with a laptop. And then, at some point, it gets a workstation. And then-- it was really funny. When we were taking the data, we started making it bigger and bigger. And then, we started telling the theorists, hey, guys, you better start get the work.
And it took them a while to get the last few data points to get it in the data center. But you could tell that the computational complexity was getting really, really steep here and it got harder and harder for them to check. But fortunately, everything checked out OK.
And then, the last point here, this is in a big Google data center. I don't know, maybe 100,000, a million cores-- huge amount of computational resources, and it took a long time to check. So here's data that we checked, and everything was OK. We then decided, OK, let's change the circuit a little bit here. The computer program is a little bit harder to check.
We then took data. But the problem here is there's no red circles, because it just took too long to check. We couldn't check it. So what do you do then? So what we did then is we did a similar circuit.
In this case, we just broke the whole circuit up into two. There is no gates connecting the two sides. We can calculate each of these separately and check it. It's more or less the same number of gates. And then, the blue you see, it follows here. So the blue data here represents-- it kind of represents what the red circles would be. And it's different than 0, and we would expect it to work properly.
And one of the things we did in the paper is-- we knew we couldn't check. But we also had a feeling that people maybe could make more better algorithms, computer algorithms, in the future. So we actually took this data here, which was for the red circles, and we posted it online kind of as a risky prediction so that if anyone built a better computer program, they can check to make sure it was working.
And in fact, people have done that. And for these three data points right here, we now have red circles. And everything agrees properly, as we expect. So it's good-- it's good that everything's working OK. And the time to do this is now days instead of years because people have spruced up their algorithms.
So that's great. It shows that we've done calculation here. B is just generating a random number. It's not useful, yet, but we've done this out at calculation where it takes a very long time to compute that with a classical computer. And you can show the power of the quantum computer. So that's great, and it shows that it works right.
Let me tell you, now, what I got very excited about with this particular data. This is nice. Google program got a lot of money, and everyone's excited because our quantum computer looks powerful. But the thing that I really liked was this black line right here, which is going through all the data.
And the black line is the prediction from the 1- and 2-qubit gate errors that I talked about a couple slides ago. You take those errors, and you just compute, what is the total error of the system using high school probability-- very simple formula. And you can understand this data and whatever.
And it basically says that the quantum computer is working properly. There's no additional problems that we know of. The physics is working right. And this is really good news for the field, because it means that as we move forward, we still expect there's no bad physics out there that would preclude us. Of course, we have to keep making things better over time, but that's very good from the fundamental physics point of view.
So at this point, let me talk a little bit more about what you can do with it. I think one of the big applications of a quantum computer is to do quantum chemistry and quantum materials. I don't know if there are any chemists, but a big thing in chemistry is using supercomputers to figure out what the chemistry is of a molecule. And about 10%, 15% of supercomputer time is used to do this kind of thing.
And it's a very difficult quantum mechanics problem in the same way-- same reason that quantum computers are powerful. And the idea, first put forward by Feynman was you would take your very hard quantum physics problem for chemistry and somehow map that onto a quantum computer efficiently, run it on the quantum computer, and then you can get an efficient solution. And in fact, people have done this. It's taken decades to figure that out. And there are some algorithm for doing that.
Here's just an example of data. Maybe people remember from chemistry class that if you take two hydrogen atoms and you bring them close together, you'll find that the hydrogen molecule is lower energy and it binds together to form H2. And there's this classic dip of that energy versus the distance between the hydrogen atoms.
And this is just a little demonstration experiment. Instead of H2, they took 12 hydrogen atoms in a row and put them together. In nature, you wouldn't find that, but that's something you can calculate here.
And the quantum computer gives you these blue dots from running this algorithm properly. And then, the conventional calculation gives you the black line. So everything agrees really well. You can do a significant number of electrons and orbitals and get good answers out of this.
And what's nice here is you take this hardware, you take this programming language at Google called Cirq, you take this open source which does this chemistry compilation, and you combine all that. And then, you can do, relatively straightforwardly, these kind of calculations. And this is just an example of a couple other algorithms that they ran.
And all I want to say here is in these particular algorithms, this is the total number of gates that we to do the algorithm-- the single-qubit and two-qubit. And all I really want to say here is we can run hundreds to thousands of gates, and this basically says, these quantum computers that we made at Google is now powerful enough that we can run complex algorithms. It's still something you can run on your laptop, in most cases. But it's complicated enough that you can see how it runs, and you can learn about that and bring up the expertise of the field so that in the future you can do even more. So it's really at an interesting level right now for the quantum computing, at least for doing science and understanding how the machine works.
I want to say that I've talked about this experiment and superconducting qubits. There's a huge number of quantum systems that people are looking at. It's a very vibrant and varied ecosystem. At dinner, we were talking about the various systems and their pros and cons. And it's really interesting right now what's going on.
There are superconductors. There's ions in little electrical traps. People do computation with photons, with light, semiconductors, diamond. There's superconducting annealers. It's a wide variety of systems people are looking at.
And it's just an interesting time, because they're building these systems. And you get to look at system performance, like I showed before, and you can see what's working and what's not and what you might be able to do in all the systems. So it's quite an exciting time to do this.
In terms of the algorithms, I talked briefly about quantum chemistry and why that's important. Maybe some of you have heard about that quantum computers breaking-- oh, breaking the internet, if you want to call it that way. And that's basically there's this RSA protocol which is based on the fact that if you take two large, prime numbers, it's easy to multiply them together but very hard to break them up into the factors. And by sending-- communicating the large number in a certain way, you can then do very secure communication. And that's what most of your internet security is based on.
And the problem here is that a quantum computer might be able to do this factoring very efficiently if you build a very big quantum computer. So people are worried about that. Eventually, you have to replace those protocols.
And then, besides that, people are thinking about quantum computers for optimization. A standard way to think about this is the traveling salesman problem. You want to find the shortest length visiting all these cities, and there are well-known algorithms for doing that. But there is some thought, maybe, you can use quantum computers for this kind of problem or for machine learning to, say, do better translation on your products from your favorite company. So a lot of things people are looking at.
I like the quantum chemistry algorithm the best, because we the algorithms. We know what to build. We know that if we can do that, you're going to make a strong impact on chemistry. And I think that's really great that we have a known algorithm that we want to work on.
So what are people trying to do in, let's say, 10 years? So both Google and IBM have talked about building a million-qubit machine, error corrected, solving chemistry problems. It's very hard, very daunting. We'll see if they can keep to it. But people are really thinking very seriously about doing that.
If you're worried about breaking the internet and RSA encryption, you need, maybe, 50 million qubits or so. So it would-- it's going to take probably longer than 10 years if we can do that. It's hard. I also want to say that China has reproduced this experiment I talked about, and they're working very fast and very focused. So it's quite a big, international competition, now.
And then, finally, just as in conclusion, if you're worried about encryption and whether your internet's going to be safe, all encryption methods have a certain lifetime. And given that a quantum computer might be built in 10 and 15 years and we want to protect all our data right now, basically, people should be thinking about retiring RSA. It's at the end of the life, and it should be retired at some point. And certainly, government agencies know that.
And the nice thing is, there are algorithms that people know about right now that are quantum-resistant and it would be very hard impossible for a quantum computer to break. So people are working right now, and this has a good program. They're probably about halfway through right now, and people will be developing that. So your internet will be safe long-term, but we'll have to get to the next level of protection to get there. But yeah, the real thing for me as a hardware person is, we need to build better quantum computers to be able to do these interesting things.
So with that, I'll come to a summary and conclusion. Here's a picture of the device with all the wires connected up to our control system. It's all opened up so you can see what's going on. And basically, I wanted to show that this experiment-- and we're at a stage now where we can build powerful quantum computers, that they have-- the power of the quantum mechanics has been demonstrated that classical computers really can't keep up with that.
And they work as expected. There's no error mechanism, no physics we didn't think of. Of course, we have to make them better. At the next thing people want to do is build something useful, of course. And that's going to be improving the hardware, and at the same time, looking at the algorithms and somehow make them simpler, or easy to run, or smaller in some way. And the field is working to bring these two together. And then hopefully, at some point, we'll be able to do something useful.
And that's a very exciting time, and we'll see we'll see how it goes. But the future looks quite interesting for this field. And there's a lot of promise to build something useful soon. And finally, I just want to mention there is a big team at Google doing it.
This was about the time-- picture of the, mostly, of the hardware group at the time we did the quantum experiment. And it was only with everyone working together very diligently we were able to solve all the problems and get this experiment to work. And thanks to everyone who worked together to do that. So with that, thank you very much. And I would love to answer questions now.
AUDIENCE: Yeah, so [INAUDIBLE].
JOHN MARTINIS: I'm hard of hearing, so I'll get close.
AUDIENCE: That's a great talk. So in the 10 years that Google [INAUDIBLE] would make 10 million qubits quantum computer. So for 10 million qubit, if you need 10 million wires to cross to the gate.
JOHN MARTINIS: Yeah, so for a million qubits, one of the architectures is to bring in a million wires to connect to the qubits. Now, you would like to multiplex and do that. And people are thinking about reducing the wire count.
But you have to remember that we have to make the errors better. And if you're going to multiplex and simplify the control system, your errors are probably going to go up. And I'm going to say that for all the qubits right now. They all have way too much errors.
And just wiring them individually in the qubits is a way to keep the errors low and to calibrate it right. So that's a big problem, because you have these two system requirements of low energy-- low errors at one side and trying to reduce the wire count. And those constraints are pushing against each other. So that's a real problem.
But Google does have a way that they think about doing that. As IBM has their own way, PsiQuantum and Photonics, they have another way to scale up. There's some interesting ideas out there now. But again, you have to get the errors low, and you have to be able to scale up and wire. That's a big challenge.
AUDIENCE: Thank you for the talk. So you were talking about [INAUDIBLE] a little bit. And [INAUDIBLE] quantum-resistant friction algorithm [INAUDIBLE] start collecting lots of data now that's pertinent. And then, even if people switch to quantum-secure encryption later, one could-- 15 years or 20 years from now, once we have quantum computers that run [INAUDIBLE] algorithm, one could take this old data, decrypt it, and get [INAUDIBLE] social security numbers [INAUDIBLE].
JOHN MARTINIS: So did-- I didn't--
SPEAKER 1: So the question is, if you have data now that's out there, 25 years from now, you could decrypt it and it still might be sensitive.
JOHN MARTINIS: Yeah, that's right. And I was, for example, at a government program review kind of thing about 10 years ago. And people in the government were worried about that now, because some of the secrets of the government they want to keep secret for 50 years or more. And there are people in the government who worry about that.
So 10 years ago, they were worried about, how do we go to the next level of encryption? And my guess is people have already doubly-encrypted it in some way for really sensitive data. But yes, and that's why I say, maybe quantum computers of RSA breaking is 15, 20 years out. But let's say in 0 to 5 years, people should be worried about doing that. And so they should be thinking about it right now.
Now, there are security experts, and you want to listen to them. But we're making progress in the hardware. And we shouldn't assume that it's decades and decades off. It might be sooner.
AUDIENCE: I have been following this field for quite a while. And while I don't do quantum computing, I do a lot with classical computing. And for classical computing, there's [INAUDIBLE] and proofs. And you can prove theorems, but that's not how anyone programs. You get on, and you start messing around.
So the problem with the quantum field is that the whole field started with theorems and [INAUDIBLE] which scares the bejesus out of chemists like me. So is this quantum computing field in a regime now where someone can get on the quantum computer and play around?
JOHN MARTINIS: Yeah. And for example, IBM has a very nice service for doing just that. And they actually have a pretty good business now of people going on and testing things. I think their quantum computer is still quite rudimentary, but is good enough to try things, and I think that's great. And my particular view-- this is what happened with classical computers-- it's only when people got on it and played around with it were they able to really be quite inventive to it.
So although we see some applications now, I think it's going to grow once they do that. And again, I'm going to give you one particular example. Machine learning has been around-- and neural nets have been around for decades, now. And it was only once they started getting bigger computers and data centers and big data sets that they were able to actually put something-- in some sense, people were playing around in that way. There's no theorem.
In fact, the machine learning algorithms, it's only until recently that people think that they understand the theory. So a heuristic approach to computing has been around for years. And I kind of expect the same thing here. It is going to be a little bit harder because of that.
One particular example of that is there was one person on the theory team in Google who did not go through a physics program and was a computer scientist and taught quantum himself and worked on the team. And he broke a very important theorem about making Toffoli gates with a number of T gates. But you know he broke an important theorem because he didn't make the standard assumption that everyone made.
He made some clever assumption, which was fine, and he thought about it differently. I'm sure that's going to happen over and over again as people come in with wildly different ways of thinking about it. So that's one of the reasons I'm optimistic in the way you say.
SPEAKER 1: [INAUDIBLE] I have one quick question. I don't want to take you into too much detail, but you mentioned that in the three years since you did the quantum supremacy, the classical algorithms improved so that something that you would estimated would have taken a few hundred years in 2019, classical computers haven't gotten that much faster. But now [INAUDIBLE].
JOHN MARTINIS: It's a more sophisticated algorithm.
SPEAKER 1: [INAUDIBLE] and the question is, what was the algorithmic improvement? Was it something specific to this problem, or were the algorithmic improvements more general?
JOHN MARTINIS: OK. So I think you stumped me. That's good. But these are very difficult and technical calculations. In fact, what they do is they break up the array into two separate arrays and solve the equation on each half. And then, they piece them together with kind of a Feynman path integral.
And the subtleties of breaking that up-- I think there are some cleverness here. So I think these new algorithms are a little bit specific to this. But I think it's still an advance on how people know how to calculate these complex things. And that's good for the field. And I actually quite pleased that people looked at this experiment and developed better simulation tools.
And especially, yeah, you have to break it up to run it on a big data center. And that, of course, takes a proper understanding of computers. There's a--
AUDIENCE: Do you think that the large-scale chips can stay 2D, or will you have to go 3D?
JOHN MARTINIS: What was say?
SPEAKER 1: Can the large-scale chips stay 2D, or will you have to go 3D?
JOHN MARTINIS: Yeah. OK, good question. The 2D chip we made was, actually, also to do the surface code and error correction. And we particularly did it that way so it would be forward compatible to doing that. So I don't think you need to go to 3D to do that. Maybe 3D might be better for certain algorithms.
But in the end, you're going to want to do error correction. And then, that kind of chip is good enough. And you're just going to make it bigger. So it was an important experiment in that we kind of proved out that this kind of architecture worked OK.
And it's nice that-- this is the talk I gave on Monday-- but it's nice that the theorists were able to come up with an architecture in 2D that we can build. And that's what got me-- you quoted my email. That's what got me so excited 10 years ago is this well-performing thing, when performing architecture and theoretical idea, was something we could build. And I think that was kind of a magic that that happened.
AUDIENCE: The one unresponsive qubit on [INAUDIBLE] process, what implications did that have, and what were the possible causes?
SPEAKER 1: What were the possible causes for that one malfunction in qubit 956, which is the [INAUDIBLE] the one on the top?
JOHN MARTINIS: Thank you. I appreciate that question a lot. So this was the first device we cooled down. And we just got everything to work, and we didn't expect this thing to work. Let's cool it down, see what's wrong. We'll make a better one, fix things. And it turned out to work great.
But what happened is we only had one of these printed circuit board mounts. And the one line going to that qubit-- we measured a short in it. We knew it was wrong. And if we had another board, we would have used that, too. But we then have another board.
So we just figured, eh, OK. It's at the edge. We'll be OK. It's not going to work anyway, so let's cool it down and try. And it turned out to be great. So I guess we got lucky. OK, that's great.
SPEAKER 1: Did you produce anything bigger in the three years since?
JOHN MARTINIS: Yes. Yes, they have built new chips. And they're working on a bigger chip than that to do the surface code properly. So it's all scalable. You can make it right. Making the qubits reliably is a little bit of a challenge, though. The circuit board-- the first time you do something, it doesn't go right. It's normal.
SPEAKER 1: If you're going to resolutely refuse to tell us what to invest in, we'll take one last question.
JOHN MARTINIS: OK. Well, you invest in what has good qubit errors. That's my advice. But it's physics investment advice. But yeah, if I were to open a journal tomorrow with 10 or 20 qubits but 10 the minus 4 error, I would say, that's the leading qubit technology. That's how important for me errors-- one or two qubits, no.
But if it's 10 or 20, you're kind of a big system-- that would be like, OK, they've really shown something. We have somebody that you did not previously ask a question.
AUDIENCE: [INAUDIBLE] believe that superconducting computers will continue to be the dominant [INAUDIBLE] system, or that [INAUDIBLE]?
JOHN MARTINIS: So whenever you ask someone about their particular system, they always say it's the best. So supercomputer is best. My real statement here is, I don't know in the end what's going to be the best. And you just have to build the systems, and you have to see what works. And you see if you can do all the system engineering.
And right now, there's a bunch of different systems that are getting funded. And then, we just have to wait over time to see which ones work well. The one thing I can say about the superconducting qubits is I think we can make them a lot better. They're already almost 10 times better than the other systems. And I think we can make them even better.
And I think it's also possible to scale them up, although that's a big industrial effort. So I feel very positive about it. But people out there are really clever, and just look at the data.
That's what's nice about the field is you look at these systems, and you can kind of tell. But you have to look at the errors. It's not just the number of qubits. I think people got it. Thank you.
SPEAKER 1: So we've learned that he's not investing in trapped ions. With that, we'll thank the speaker again.
JOHN MARTINIS: Thank you.
We've received your request
You will be notified by email when the transcript and captions are available. The process may take up to 5 business days. Please contact email@example.com if you have any questions about this request.
Nature allows the storage and manipulation of data in new and powerful ways using quantum mechanics. John Martinis explains the basic concepts behind the exponential power of this technology and how to build a quantum computer using superconductors. He shows recent experimental data on a “quantum supremacy” experiment with 53 qubits: the Sycamore processor takes about 200 seconds to run a quantum circuit a million times - the equivalent task for a state-of-the-art classical supercomputer would take approximately 10,000 years. Finally, he explains some of the future uses of quantum algorithms and what may be in store for the field in the next 10 years.