 I'm very happy to open this conference and talk to you about some of the recent work that my group and I have been doing now in the area of error correction. Some of the people that actually did this work are here. Peter Johnson is there, Jonathan Romero, Jonny Olson, Judon Kau is in California right now and anyway, so please feel free to ask them questions. I actually wanted to begin in a similar tone as Jay actually, I didn't see his lights before but I think it's very important to think about what to do with a 50 to 100 qubit quantum computer in the context that he mentioned so I'm not gonna elaborate on this idea that we want to think about not only the number of qubits but also how many gates which is roughly a thousand nowadays you can do as depth and that defines what IBM calls a quantum volume. I'm showing you here a picture of the IBM machine because we are at IBM and of course there's machines built by startup companies like Rigeri, there's machines built by Intel, there's machines built by Google, etc. So I like to call this the issue of variational algorithms. I mean there's something common in a lot of the algorithms that we're talking about as early applications for this technology and it is because we really don't have a lot of circuit debt that we need to think about this heuristic type of algorithms that might or might not have an advantage but hopefully we'll do something interesting. So Jared McLean which is here somewhere is the architect of this, there he is, the variational quantum eigen solver which became a very popular technology for trying to find ground states. This is a picture just to bury it a little bit, a picture of the Google experiment doing the hydrogen molecule. We just saw earlier the IBM experiment and this paper is actually not this, I apologize, this is a paper for the first quantum optics experiment and I remember we were already talking about this in the 2013 conference here so this is kind of like things are moving pretty quickly. Eddie Farge also present here somewhere introduce a very powerful or heuristic algorithm, this quantum adiabatic optimization algorithm and I think it's powerful in the sense that it's very compact and will potentially show interesting results as these machines become having larger and larger quantum volume as it's called. We recently introduced a technique that we like a lot, Jonathan is here as well, the quantum auto encoder which is a way of using this Chaluse circuit quantum computers to compress quantum states. So so many people have been saying you know there are problems in quantum machine learning when you actually try to feed classical data on quantum computers. This algorithm is designed more for quantum data. If you have quantum data we hope there is some sparsity in terms of its representation. For example it's not optimally represented in the quantum computer and by using this encoding decoding circuit you're able to compress the quantum information and therefore generalize from it by moving around in this so-called latent space. So the talk is not about that but it is true that this inspired us for this error correction scheme I've been telling you about. Even in the paper we were thinking about how can we use these tools for error correction because it has similarities. And finally we used to use another paper that we're very excited about, you don't count it's not here. Also we know Giacomo Gurecci. We call it the quantum neuron. It's a little bit longer term because it requires a lot of measurements and repeated until success. But it is a quantum machine learning algorithm that has this little unit called the neuron that reverts to the classical neuron of classical machine learning. So it has very interesting properties. It can be trained in parallel and you know because it is it can reverts back to the classical one. It has a limiting which is the classical one. You can actually borrow technology from from classical machine learning. So in these early machines probably we'll be able to do a very very simple experiment and of course we don't expect this to be beating Google at classifying images of cats or something like that. So anyway I believe this is kind of like a sampling of some algorithms as many many other algorithms that use this a variational approach to quantum computing and in all of them you train quantum circuits. That's kind of the main goal of these algorithms. You don't know what are the right parameters for any of these systems. This is a neural network. This is optimization etc. So you're moving around the Hamiltonian sorry the gates the gate parameters and trying to for example minimize energy in the case of the variational elegant solver, maximizing the code size in the max code problem, optimizing the compression of a quantum state or minimizing a loss function for a machine learning problem. So all of them have this joint ideas. So on the other hand many people here including us as well and thinking also what was going to happen in the long term right there's going to be this transition into a recorrected algorithms that we all know and love. For example Hamiltonian simulation beautiful paper recently by Andrew Childs and his co-workers on what would be like realistic limits of when we can beat a classical computer. Of course short factoring algorithm Grover search quantum machine learning with classical data you know all these quantum RAM algorithms. Adam Harrow is also here with his algorithm with set Lloyd and Hasidim for solving linear equations and all of these require full-blown quantum error correction and therefore we have to be somewhere in between and I think error mitigation the word that Jay mentioned is an important area. So let's just begin by actually just defining what is quantum error correction and then I will continue talking about the quantum variational error corrector algorithm that we that we propose. So this line represents a quantum register or qubit in this case let's just mine it's a qubit you have a noise channel we're gonna call it n so the qubit is not perfect it's not in a perfect environment so this noise will actually of course denigrate the quality of the quantum state and by these little triangles in the left and the right where the defining is just this average fidelity of the channel right of starting in a quantum state and leaving in you know ending in another quantum state so this is you know what happens to the channel what happens to the to the quantum information after it it's affected by the noise. So the bet in quantum error correction is the fact that you know if I actually add more complexity to the problem in other words I add a set of ancilla qubits that of course presumably undergo a very similar if not the same noise process I want to point out something important to my talk when Jay showed you the picture of his 20 qubit device you notice that every qubit had a different t1 and t2 and different parameters right this is gonna be important to us because you know the traditional error correction thinking is what can I assume an error model and start playing with it whereas your machine will have crappier qubits and others and all machines do that right I mean Alejandro Perdomo has a beautiful paper on characterizing the d-wave machine in the same way like some qubits are better than others so the way our correction works then you have some sort of encoding v circuit and some sort of decoding type of operation that actually will allow you in principle to distribute the quantum information over these qubits and quote-unquote fight the noise and hopefully improve the fidelity of of of your preservation of your quantum state so the bet is that actually adding all this complexity will allow you to actually have a better performance than just a raw qubit and that's kind of the philosophy of our correction a very long very very long-standing idea obviously so what are the prospects for state-of-the-art error correction so that's the first part that we're gonna just review I will say one of the state-of-the-art algorithms perhaps one of the spears you that lot in industry at the moment is a so-called surface code it has many interesting features is realizing a two-dimensional architecture it has local syndrome measurements and people have demonstrated gate operations below threshold so we're on the route in principle to actually building a machine in the surface code and again many of the industrial players are focusing on building machines that realize an error correction scheme it could be another one and the reason this is so attractive is because it's like an instruction manual you know if you if you follow the instructions of how to build a machine that does the surface code you might eventually end on the other side of the of the of the journey with an error corrected machine so so now let's just look at Google's 49 qubit processor as a function of little blue circles in a slide okay so it looks very daunting and very exciting to have a machine of this size so now if you actually think about mapping a logical qubit now a qubit with realistic parameters of the surface code in in a bunch of qubits we're going to just put to scale Google's 49 qubit processor with all the qubits you need to map a single logical qubit and I'm very optimistic as always I believe we're gonna get there and I think this conference is well what are we doing between we build this monster quantum memory the last forever and the machines that we have today so is there a hopeful alternative that's what my group and I were thinking about this is a very old question you know here is loin loin loin Nielsen and Chuang you know in the case of the laboratory what works with a specific apparatus with a particular domain and quantum noise process right and in that p.r.a. paper they also say that the error correcting codes that are kind of idealized do not take advantage of specific knowledge of the particulars of your device and therefore might be suboptimal so this is a question that we're trying to look at so how can you gain specific knowledge of the noise to actually do a better a better performance so this is of course our pictorial way of representing the coherence in a single qubit we have here the density operator and the T2 process phase damping what it does is basically kills the coherences in the device the T1 process amplitude damping is relaxation back to the ground state of the device right so these are kind of the two physical processes one is kind of like jiggling noise the defaces and the other one is just basically relaxation to a ground state that actually kind of define the noise processes that can happen to the quantum state a formal way of writing them is of course discuss operators they are just green here I want to you to remember that they are this coherent mixing of these Pauli operators x plus I y I minus C I minus C this is gonna be important later okay for the purposes of our discussion but basically here we have the noise processes and notice that the T1 and T2 obviously can be just mixed into this gamma and lambda parameters for this for this you know map that the coherence just is very simple model so what is the quality of error correction for this process let's think about a raw qubit with you know typical parameters we see as we as we wait you know and here are the parameters the T2 of 60 microseconds you actually look at the average fidelity coming down for this very simple one qubit experiment and you hope that something like the five qubit code will actually do better at least in certain parameter regimes right so this is a encode wait and then decode type of scheme okay very simple so the five qubit code is gonna have these logical operators here are all this like transfer CCCC and xxxx that actually perform logical computation and the stabilizer operators that actually allow you to detect if there were errors in the qubits you know so this is the very traditional classic scheme that we are comparing against and if you actually look at this five qubit code now here in in orange or light orange you can see that many things first of all this thing is designed for actually you know very very short times looks like you get very very good fidelity after a while after a lot of waiting time then it's better all you're better off by just running your your rock on one computer and not doing this error correction I will dare to say that we are in the parameter regime of quantum devices that we're somewhere around here where it's not obvious that it makes sense even sense to do this error correction right and as we build better and better devices and get better very coherences then in the next three or four to five years this variation algorithms will be mixed with these error correction schemes whatever mitigation schemes that we're talking about so what is the optimal scheme you can go back to early papers by Fletcher short and zine and kosut and lidar where the question is well can I find the optimal the ultimate the optimal map that actually corrects for errors right given a particular noise model okay so the way it works is you want to maximize the average fidelity and then you have decent coding and decoding so you optimize first the the the for example in this particular case the decoding given giving the coding fixed now you optimize the coding given the decoding fixed and then numerically just go ahead and you know try to converge to the best possible encoding and decoding schemes and then you declare victory at a certain point of course therefore the plot that I'm showing you here might not be completely optimal this we did it numerically and we stopped at a certain point but it shows you kind of like a like a good practical upper bound of what you could do if you were able to actually invert this map and look at error correction with that perfect type of encoding decoding type of architecture and you can see that it was very very similar to the five qubit code at short times and then you know it starts outperforming especially longer waiting times which is something that we would like to have in this early quantum devices you know we want to kind of do the least possible error correction on the most algorithm right we don't have too many gates so we argue that this approach is very elegant but it's not practical first of all you need a noise model and you know for getting that noise model you need to do benchmarking right you need to know a lot about your system will it be nice that you benchmark the system at the same time you're learning about how to do error correction and the algorithm ultimately you want to do everything together so you need to require a noise model and you know the optimization of this in general that map will scale exponentially with a number of qubits to actually encode a general type of encoding decoding scheme so that's another broad block for this algorithm and again the other problem is that you will need to do a compiler to actually try to get that map which anyway we know that parameters for it will scale exponentially so we know the circuit is going to be very crappy and therefore we have to have something in the middle this is going to be a great idea but it's not going to be practical so we introduce Q vector so Q vector is an algorithm that tries to fight all of these things because we have first thing is we don't we try to start with a model free architecture we just say okay there's no noise in the machine let's learn it we want to have an efficient evaluation of the of the of the optimization with therefore we want to have like compact circuits and we make an ansatz like in the variation of the ligand solver make a circuit ansatz for error correction so you might argue about our circuit ansatz I bet you many other people we have better ansatz there but now this is a game everybody can propose what is their favorite circuit architecture for encoding and decoding the error correction and we can all learn from each other what is a good way of encoding the other thing that is not here but it's also important is that this might be very problem specific as well if your problem is encoding in a particular subspace you might be better off you know so there's some other things that could happen here so Q vector so let's just animate like this so you remember the name of it so again it's a very simple encoding that looks similar you encode go through the noise process and decode and our objective again in the in the in the variational type of context is to maximize average fidelity so how does it bypass the roadblocks the first thing is okay very simple observation noise models itself exactly right so if noise is there well you might as well just not use a noise model just look at the noise directly so we optimize on the hardware device directly and the idea is to figure out how to do it so this idea of to design okay that has been around for a while uses basically Clifford gates which is shown to be sufficient to actually estimate the fidelity this is related to a lot of work I was just in the boss hearing to Joe Emerson talk to Adam Harrow they were talking this is based on work from him and others a lot of work in literature about this type of things but you know you basically you basically measure just zero and one with these two design type of sampling scheme and then you basically count the number of zero outcomes and that will give you the average fidelity as you increase the number of sampling okay so that's basically the way we do it so we we basically encode these gates and then we do the two samples encode decode and measure and variationally optimize and maximize that fidelity the other things then we define circuits that more or less look like this they have gates that allow you to encode and decode the quantum information so the way this looks like it's very similar to the variational eigen solver and other algorithms like this or the QAO you have a classical optimizer these parameters vectors p and q are the parameter vectors of these circuits and therefore you basically provide the fidelity change the p and q and the classical optimizer is driving the quantum computer something interesting that I heard from Arturo Mezacapo at the conference recently is that for doing variational eigen solver at IBM just even transferring back and forth information between the classical computer and the quantum computer takes a lot of time so a lot of these different things have been people have been discussing okay let's put a very fast classical computer next to the quantum computer because a lot of these near-term algorithms will require a lot of back and forth so that's pretty exciting this will be the same case here because you need to measure quickly optimize and so on so the entire scheme is summarizing this slide hopefully I've been going slow enough unlike me that I usually don't explain things slow to show you how it works then you sample from the to design initialize apply the map measure optimize the average fidelity that's basically what the quantum computer is doing okay and then and again these encoded circuits are actually predefined and you can assign your favorite so of course for the end of this talk let's how does this look like is this like a cool thing to do or is this just hopeless so just to remind you this is a single qubit error the five qubit code and by convex optimization again kind of like a benchmark to look towards but not practical let's sit down a four here this for waiting time okay just because we want to have the longest waiting time possible to apply this algorithm I'm gonna apply Q vector there and this is what we get makes a lot of sense it's not perfect it's not gonna get as good as say cost of the Nidar's type of general scheme we don't have enough parameters to get there but we do better than both the single qubit and the five qubit code and you can optimize there and then extrapolate you know you see it everywhere else and you get this kind of linear behavior like so but it's not next fully linear Peter Peter Johnson and I were putting a little envelope in our PowerPoint slide to see how linear it was we have to characterize it better but you notice that of course we optimize here is not gonna be optimal over here where currently starting to do experiments to try to understand how we optimize it the different waiting periods how does this look like but I had to confess it's very hard to optimize these things too so you have to know that the classical optimization area for this is actually a big a big big effort and Hanna sheen one of my students here is working with Jonathan in a software package that hopefully we can release and help people see what's the best way of optimizing these parameters so I think we all as a community should learn a lot about optimizers so now why does it outperform the five qubit code that's the last topic I'm gonna mention okay do you remember I kind of emphasized that these noise processes are these coherent combinations of these Pauli operators so this K2 is X plus IY for example and I be an approximation that is used not only to design but also to simulate errors in computers makes a lot of sense and my group and I actually have employed it to simulate for example how quantum chemistry degrades you know in a computer it's just say well you know we're going to a certain probability flip cubits X Y and Z this is called the Pauli tooling approximation easy to simulate easy to analyze mathematically etc but it's not connected in some sense directly to the physical process that you are expecting the relaxation and the facing okay so there is coherence what I'm called in this process is and here you have this incoherent noise process so let's look at how the models fair the exact noise model and the five qubit code will give you 8.9 and in the power to the approximation it will be the same again because it's designed to fit this type of error model of the Pauli tool approximation okay the numerically optimized does better this is the one that constantly that I say optimizing the map and then if we don't allow it to have coherence this if we allow it to kind of just live in the context of the Pauli tool approximation it does worse but you know it still upperforms the five qubit code because it's optimal and finally Q vector in the exact noise model performs a point 912 and in the power to the approximation it makes sense that we're not as optimized as the five qubit code okay but what you want to look at is actually this number here okay because we all perform the regular codes and you know we are somewhere in between them and the numerically optimized so that's kind of like the message so we say we're exploiting the part the public coherence because we are doing better than the the five qubit code so it's a way of explaining why this is better than than then perhaps just using a raw code and I think as we learn how to do things better as a community there will be much many more improvements on this quantum vector by no means of if this is gonna be the last word on the subject so we want to now of course this was just kind of preserving quantum information how does this work with gates is our next thing right so how we preserve gate operations we want to try to do a lot of numerical experiments to try to find out what is the best circuit ansatz as compact as possible because we don't want to waste gates and obviously we want to work with any maybe remotely over the internet or with a lot of our partners and friends and the different places to actually perform this on existing hardware I think this can be done today and I think this is why this is a good topic to discuss in this conference the final thing is I'm gonna say that not only quantum hardware companies are spawning out like like mushrooms there's also quantum software companies spinning out like mushrooms and we couldn't resist to create ours okay so ours our goal in our company is to have a platform neutral neutral focus quantum software startup that is neutral we work with everybody we want to learn we want to develop algorithms for the applications that I just showed you about okay and this is kind of like I like to say companies are kind of like the CIA and my group is kind of like the like the embassy okay in this kind of Russian spy novels things kind of you know so so if you want to think about us we're currently expanding and hiring and I know everybody's expanding and hiring so our company's name after a Mexican Revolutionary Colin Miliano Zapata that brings revolution to the masses okay so this is our logo this is meant to be some sort of optimization landscape and again basically Johnny Jonathan and Peter are proud members of Zapata Anders here as well so so talk to us about Zapata and with that that's the email and with that thank you for your time and this is a picture of my group in the excited state before it relaxes to the ground state and with that I think I have some time for questions thank you okay some questions for a lot yes I understood that you were looking at essentially a memory channel and optimizing the average fidelity of that channel have you looked at how your optimizer performs when there's noise on the gates used to perform the algorithm itself yes that's something that we're looking at and we inspired by your work on that it's of course it's a weak point of this algorithm like the gates themselves for example for a for example even for a 2D sign will not be perfect and yes we're looking into that and you know learning from what you have done in the past as well yeah any more questions I see a question there um how would you sorry yeah how would it be possible to build a like if you go to a large and larger system suddenly you need a decoder to interpret the result of what you see for your qubit would it be possible to use this variational method to build something like this or can you repeat your question sorry sorry it would it be possible to use this variational method to build a decoder for a larger a larger quantum error correcting code because once you get to a large and larger system then you can't just I mean you know with a five qubit code I can just take the result and use a lookup table to figure out what I think the errors that occurred are but if I go to a larger system then that's not possible so yeah that's how I hope is that this thing scales up and you know of course the number of parameters in the encoder decoder that we design roast polynomially with the size of the system and yes maybe we'll get to a system large enough that that this is the only thing you can do if I understand your question okay yeah we can talk offline and also Peter the first author is here if I didn't get your question hi Alon so over here how did you run the numerics for the five qubit code you had to pick a decoding algorithm to do that but you didn't you didn't say explicitly what the process was I mean you stated you fixed the T1 and T2 times right but those were coherent errors so how did you pick the decoder for the five qubit code like what were you comparing to well we execute like textbook lab textbook type five qubit code right we just measure the stabilizers and all that stuff right Peter you were just applying Pali error correction there okay that did you did you compare to where you fix the five qubit code but you optimize just the decoder that is it's the optimal decoder using like the SDP okay so the question is when you encode and decode this way can you do logical operations fall tolerantly as well does that put more constraints on the encoding this is exactly what we're trying right now this is I mean we first wrote the paper just like encoding and decoding but we hope that you encode carry out look logical operations and optimize everything together will be probably something that will work but that's what we're doing numerically but we're having a side step because we're rewriting our code to have a much better optimizer before we do a lot of numerics again okay thank you so Jonathan how does the circuits the parameters of the circuit scale is a number of so repeating Jonathan linear scaling actually 40 was quadratic I learned so yeah good any more questions I see so when you compared the Q vector approach to the the previous approach that does offline optimization of the encoding decoding circuit you commented that there's an exponential cost to that offline classical approach in the number of qubits and it seems like there are two exponential costs here one is in simulating the noisy dynamics on n qubits which is a subroutine for the the optimization classically and you eliminate that by just performing it on an n qubit quantum computer with you vector that's correct but there's another slowdown which is in the landscape the space of circuits that you need to optimize over which is very large and quite possibly very very complex so to be provocative what if I were to say that I'm concerned that the that your algorithm even though it drops one of those exponentials is gonna get horribly bogged down in that nasty landscape very good question we're actually where this goes in right with Peter earlier so our numerical experiments today show things like for example using swarm optimizers is like a good strategy you can move in in the space and have several tries of getting to the global minima but we also find several minima that are near optimal like so we might just land in something that is quite good enough and never get to the optimal optimal optimal one but you know we we satisfied with that that's our current understanding of the landscape as we're exploring it in a few qubits like correctly so I mean if you want try to do it numerically with 20 30 qubits and we can do that with a lot of the simulators that are out there it will be interesting to see that and even better when we have a 50 qubit device from IBM or Google or Regetti or whatever to actually try it there yeah that would be the next characterizing that in your landscape but we are aware of that luckily we have found that we land in many near-optima and I mean this is paper that's very controversial by rabbits that says that you can do that in an optimal control and so on of course that's very idealized and it's not I don't necessarily believe that resolved very much but he plots something similar to what we see that there are many minima any more questions well we do have a little time maybe I'll ask a question it's a it's a little bit going maybe to the next step if you end up with these kind of random codes how will you do logic on the we will optimize the they will optimize the circuit the coding the coding for a particular circuit for example so it's like you know and then in principle you can you can vary parameters in that circuit and see how well it does right for example we have stencils for for variation like insolvers that the parameters are very similar you're optimizing you know so that's that's we hope that this is gonna be useful that's similar to the question we had before we see local T1 T2 model right yeah if you did a depolarizing model does your cue back find the same solution as the optimum numeric optimize or do you understand for other noise models when I don't think we I don't think we have run it through it's through more sophisticated noise models but we should yeah like see collective collectively what happens the collective noise and correlated noise and things like that yeah okay let's thank a lot