Dynamical decoupling of encoded information
CC Attribution - NonCommercial - NoDerivatives 3.0 Germany:
You are free to use, copy, distribute and transmit the work or content in unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Paz, Gerardo
It is widely accepted that a quantum computer will need some form of protection against decoherence, and to date the only tool capable of providing fault-tolerance is quantum error correction (QEC). Here we study the interplay of Dynamical decoupling (DD), an open-loop non-fault-tolerant capable decoherence suppression method, and Quantum error correction codes. Several schemes exist where DD is used to improve gate fidelities, such as Dynamically Protected Gates or (Concatenated) Dynamically Corrected Gates. Several authors have combined DD and QEC with different degrees of success, showing improved gate fidelity but at the cost of, in cases strong, extra locality constraints on the error model or a sequence size which is exponential in the number of physical qubits (n). In this work we introduce a dynamical sequences that use as pulses elements of the stabilizer and the normalizer of the QEC code (SXDD sequences). We show how this idea can be adapted to the leading DD schemes: Concatenated DD and Nested Uhrig DD. With this we avoid the need for further locality constraints and obtain shorter sequences while still obtaining fidelity improvements. Moreover, the fact that the SXDD pulses can be chosen to be bitwise allows a natural integration with fault-tolerant methods and the direct porting of several DD schemes for fidelity-enhanced gates into the SXDD scenario.
 Hello? This is good for everyone. Okay, yeah. So we're, again, running a little behind here. So we're off set by a little bit. Our next speaker is Harado Pazilva. He'll be talking about DD and Quantimera Correction. Hi. So since we have been listening about the issue of combining Quantimera Correction and maybe dynamic decoupling, would be some work we have been, some problem we have been working on with Daniel and here at USC. So let me give you some motivation first of, well, essentially this actually, before you mention, if you like DD Aquanism, this is what we call SXDD, where X stands for whatever you want. But anyway, so let me give you some motivation. Here you have your Quantimera Computer, which is ruled by some Hamiltonian evolution, H of S, which I guess is a form of tissue when I went away. And I will just flip so that. Yeah, so that's good. So we have our Quantimera Computer, which is actually a computer with rule by some Hamiltonian. And then of course we have the bath. And the bath is really, you can think of it as a big furnace, which is trying to heat up your computer. And the problem, of course, is that there is this system bath coupling, which is trying to essentially kill your computation. Fortunately, we have seen that you can actually isolate your computer using Quantimera Correction techniques and fault tolerance. And that is, of course, very good. But the problem is that if you're, the heat, the amount of heat that is coming in or the size of these HSB is too large, then suddenly fault tolerance is not too effective and it actually fails. Or you can also think about this that maybe your quantum correction and your fault tolerance still works, but then you require a lot of resources to do that. So I guess another thing is, well, can you actually add another filter to this heat? Can you put another lower level of protection, in this case, in the form of dynamical decoupling, that you can actually reduce the effective heat that the Quantimera Correction sees in such a way that you can still either achieve the fault tolerance that you could not before or actually reduce the amount of resources you actually need. So let us start, like, going to the point, which is what the scenario we are thinking of. So essentially, we have a quantum computer that's encoded in some NKD code where N is the number of your physical qubits or the number of actual qubits you need in your experiment. K says just the number of logical qubits and D is just the distance or the capacity of how many errors, what is related to how many errors you can recover from. So initially, we are going to consider the case where you have a Hamiltonian, which has a part which is like purely bath. In reality, you can actually relax a bit this assumption and say that it's not only bath, but it actually doesn't have to act as an entity in your system, but maybe with some, unless operator. But for now, let's consider that this is just an entity. And then you have the system bath Hamiltonian, which can have terms that act only in the system or also in the system and the bath. But the point is that they are harmful. There are terms that you really don't like. So in reality, this goes through some unitary or some, let's say, we just call it tau minimum. And it will make sense afterwards why this is a minimum. But this is just a traditional unitary evolution. You can actually quantify some effective error rate via this expression, which is just a normal for your system bath Hamiltonian times the time it takes to execute the gate. So what we want to do when we do dynamic decoupling is actually, well, I want to take, even if I take longer, I want to have a new unitary evolution, which has two distinct terms. The first one is this H naught or H empty if you want. Well, depending on who you ask. But anyway, so this idea is that this guy is harmless to your system. So if you think about it in terms of error correction, it could be that this H naught includes, let's say, a stabilizer operator. So if it's a stabilizer operator, you are pretty good, right? Because your information is, well, it's not harmed by such operators. And you can actually now measure effective error rate again in this scenario of some, when you have achieved, let's say, some dynamic decoupling of order n. And then this, of course, is just a normal of this other term that you have there. So the hope, of course, is that at some point you can show that the actual effective error rate when you use dynamic decoupling, despite the gate or the operation taking longer, then essentially it's smaller than the bare error rate. So this is all good. And this is essentially what we would like to show. So there have been some work done in this direction. And this was what Daniel was talking about this morning. So in this paper, let's call it the NLP paper for simplicity, they showed that you could actually show enhanced fidelity to the gates. And the main idea is that, well, you can think of applying simultaneously dynamic decoupling gates on each of the qubits of your computer. And, well, this is, of course, a very good idea. The issue is, of course, that for this to work, well, in principle, you cannot, in this scenario, regardless of how local you assume your HSB to be, you cannot achieve arbitrary order decoupling. And the main reason is that if you look at the minus expansion, then you will see that eventually your qubits will give you, will give rise to terms which actually commute with all your operators, and then you are kind of in a bad shape. So to overcome this problem, part of, or in part to overcome the problem, they introduced what it's called a local bath assumption. And essentially, these guarantees that higher order mannus terms never gave rise to term, to actually Hamiltonian, effective Hamiltonian terms that you cannot deal with, with higher levels of DD concatenation. So you can actually, well, maybe the issue is that, of course, this local bath assumption is not maybe as general as the most comprehensive, fault-tolerant error models that you can think of. In any way, you can actually think, well, is there any other solution to this problem? Can we actually go over the no local bath assumption to that, or the local bath assumption, sorry? And you can, well, you can actually, there is actually a solution, and it's actually a straight-forward solution. You can take, you can take in the language of dynamical decoupling, you can take that n qubit power basis, and, or either the generator or the full group, if you are doing CDD as you prefer. And this is, of course, very good because you can achieve arbitrary order. However, there may be a couple of caveats that, well, maybe they eventually may be important. The important is, well, they, they growth exponentially as a function of 2n, which we call n is the number of physical qubits. And not only that, but the poles look, the poles themselves, although at the end you can, you might say, well, because I'm doing the whole group, at the end they are applying effectively no operation at the end of the day. But every, every pole itself is, may look as an error to the code. So it may limit in principle some integration with other quantum error correction-based approaches. So what we actually want is, well, we'll say we want to choose the right group, right? We want to choose a correct dynamical, the right dynamical decoupling sequence in such a way that we need no extra locality assumptions, that the pulses rely on the code, that they do not look like errors, and that ideally we would like to get some shorter sequences to the full decoupling approach, right? Of course, all these always only make sense if we can achieve, we can actually show that our error rate is better, right? So let's, let us keep going. And well, the main observation of course is that the magic of everything is just in the decoupling group, right? So if you, maybe if you look at the problem, you say, well, if my group is too small, then it may be that I cannot achieve arbitrary ordered coupling as was the case in NLP, or I may not actually be able to decouple their Hamiltonians, which again, that would be a problem, right? And if you, the group is too large, then as happened with the basis, then maybe it's an hour kill, you can kill more terms that the one you need. And more importantly, well, the shorter sequences, the better, right? This kind of the motivation. So the main tool that we are going to use here is, is still that was introduced in a reference, how we appear here shortly in the, it was introduced in the nested or dynamical decouplings in NARU. And the idea is that you have the mutually orthogonal operator set. In this case, I will also add that condition that is a generator set. And the idea is that there is a bunch of operators, omega i, that square two identity and that either commute or commute or anti-commute with each other. So this is like the main tool. And this is important actually because you can formulate both CDD and NUDD in both, in these terms. And you can actually see that you can formulate concatenated dynamical decoupling using as the base group, the group generated actually by these, by this generator, by these moves. And you can actually use, do just plain nested NUDDs the same, the same moves. So, so what is that we are thinking of? Well, before we, I mean, reading the literature, people have thought about using the, just the stabilizers of your, of your code as, as actual, as a decoupling group. And it was a, it's a good idea, but again, you think that, if you think about it, when you do your mind's expansion, higher order terms will make, give you a logical error. And this logical error commutes with your stabilizer. So that is not good because eventually, even if you try to go into N dynamical decoupling, to N order decoupling, that term will still be there. So that is kind of a problem. However, if you actually add to these moves that a set of power basis elements, like this is like a subscript, a separate script for the logical version of this, is that encoded X and encoded C. And then you can actually show that these moves is pretty, is pretty useful. You know, that is the super moves. And the idea is the following, that you can still get this, if you write your dynamical decoupling evolution, you say, well, this is my, what is, what I'm, what I actually care about this, what is my H naught after the end of my dynamical decoupling evolution. You can see that now the dynamical decoupling evolution is proportional to the stabilizers of my group. And so this implies, of course, that this seems my, my, my code is chosen such that the stabilizers stabilize it. Then this is exactly harmless to the, to the, to my information. More importantly, I think is that if you recall that we were doing this analysis, we assume nothing on Hsb. So in principle, Hsb itself could contain a logical, sort of logical error type Hamiltonian. And this is actually, this Hsb term will, will still be pushed to this, to that sort of decoupled part of your, of your evolution, right? So this is highly beneficial actually. And so what have we gained with all these? Well, in principle, we have, well, what we have gained is that of course there is, there is no need for an extra locality assumption because essentially your, or the, or base dynamical decoupling group is powerful enough that you can always decouple at every level of concatenation group, like all the, all the terms you actually want to decouple. So there is no term that is both un-decouplable and harmful by the next level of concatenation. So we can assume, you can keep going, I mean, to do higher order decoupling as much as you want. And well, for the end, you need the case, the, there is actually this proof that we are, we are, we are working with Juan and Daniel and Greg. And then you can actually show that the same decomposition induced by the, this imbues structure is actually very helpful. And you can show that if you have the restructuring, you can go into the, into arbitrary order decoupling with these, with these other scheme. So now if you see that the pulses we have chosen are now, are now below and actually to the, to the group, right? And you can actually also use them to be bitwise. So they're in principle not only experimentally friendly, but they are transversal in the code. So for instance, if you were to think about CSS codes, then your X logical operator, or biological operator is now bitwise and transversal. So in principle, it respects your error model. So, and the fact that of course they, my pulses do not lock errors, but in principle allows for other protections, the interaction with other protection schemes. So what else have we gained? Well, let's check out, let's, let's look at the cost of, in terms of a free time evolution, or if you want the length of your, of your sequence. In fact, you can, you can check out that if the, the length, the size of your moves is now, you can rewrite it. It would initially be the number of a stabilizer plus two times the number of logical operators. But because of the stabilizer properties, you can, you can actually rewrite it in this way. In the case where there is no subsystem, then G is equal to zero. And then you see there is a small advantage here that you have n minus key, essentially you get n plus K. However, maybe the more, and of course this is here in this, here I'm showing the cost of fully decoupling and qubits. So you see that there is actually a gain. And the more interesting case is perhaps when you have system code and when you have a subsystem code and you can do, for instance, this is just the example of the Bacon-Shark code. And you can see that actually the size of your, of the fully coupling moves is actually, of course, two n squared because you have an n times n lattice. But if you do that as an XED version, because you essentially only care about your number of stabilizers, which is given by the expression and the whole number of logical generators, because you only have one logical qubit and you only have two. So you see that you're actually gaining an order of, well, a power here in this, in the size of the moves. And this is, of course, even, perhaps more relevant if you think that this is actually the exponent of some quantity regardless of what higher order decoupling sequence you use. So I guess this is, well, this is better than the other. So we are still missing to show if we are actually gaining something. So we are still not doing it. So maybe an observation I want to make is that at this point where we have completed the distances in terms of the distance, if you think about it, it's just the distance between the n qubit states, if you prefer. However, in reality, we are not truly interested in the distance between the physical states, the n qubit physical states, but the distance between the logical information is stored there. So in principle, in our calculations, so this is just about the easiest bound we can find. But of course, we are trying to work in just introducing ideal decouplers or ideal error correction to mentally actually get the correct distance. So these sort of work in progress at the moment, but nevertheless. So the problem is, of course, that thinking about this limitation of calculation, thinking, I would say that the ideal error correction or the distance between the logical information will be smaller than the one I'm going to show here, but this is still a good proof of principle calculation. So the way of doing this is, well, we go to the NLP results, which was, I think, actually this experiment, I think, maybe this cube. So we essentially go to the algebra, and what they did is that they can compute the norm of the system of the effective system, both of the effective and not Hamiltonian at every level of concatenation, of DD concatenation. So you can do this trick, and then essentially you can get a norm of this, the effective system, but at any level of concatenation, and of course, multiplied by corresponding time of total length of the sequence at the same level of concatenation. And the longest story short is, of course, that this is just a power of HSB to some power, actually, it should be, I think, Q plus 1, but in the total thing, but regardless. And the idea is, of course, that we want to compare the product of these two quantities, which is actually this one with this one. So we actually go ahead and do it, and for some particular code in this, we chose a Bacon-Schur code, because we already know that it has a very good scaling, and this is what we get. So this is a plot here of the log of the ratio we were considering before, and here we actually went through the recursive relationships that were in the DynLP paper. This is like the first order of concatenation, second order of DD concatenation, and third order. And you see that there is actually a non-trivial interplay, depending between the degrees of, the different degrees of DD concatenation for different set of values for J0, Taomine, and J, JSB, where, of course, JSB is the normal physical HSB, and J0 is the normal physical Hamiltonian we had. So here in this gray area, you can see here, it's essentially where there is no advantage of using DD, and you're actually hurting yourself. So this sort of makes sense that as J0 is larger and larger, then you lose your capability, but it's essentially related to the fact that if J0 is too large, well, your system is evolving too fast, and DD loses its nice properties. So maybe something I should say is that what we expect is that with the actual distance measured, including the actual distance between the logical information, this graph should well improve, right? But this is, of course, some speculation that requires some exact calculation. So, well, this one point extra for us. The problem, of course, of this, the fact that this is limited by the actual limitations of DD related to the normal physical, it's actually a point for the system, but problem. And of course, we want to, of course, I showed a memory sequence, and this will, of course, very, I mean, it's not terribly useful for computation, but the idea we want to show, so in the graph that we showed before, it's actually an implemented, it's actually a calculation based on these dynamic protected gates that Daniel talked about before, where essentially you do, you append, instead of making guess your gate, you put your dynamic open sequences, and then that's all good. And then you can actually do the same, right? However, also another possibility, which is actually the talk before me, which is pretty useful. And the idea is that you can actually repeat the same, you can actually port the same sequences to our SXDD thing, because essentially what we are saying is that, well, you have your favorite DD sequence and your favorite method of doing gates, when instead of using pulses that belong to the PAULY, the correct way or, well, the natural way of doing it within a code structure is just use your elements of the code. And they have some very good properties, but they're experimentally friendly, et cetera, et cetera. So I guess that's good. So in conclusion, well, we have shown that there is actually no need for extra locality conditions that pulses are in the code. And the shorter sequences, you have shorter sequences that the fully coupling approach. So this is, this last point is actually what I was mentioned before, that we are essentially not demanding anything on HSB. So if you think, for instance, the computer has a system by Hamiltonian that looks like a logical operator, then you see that regardless of how powerful, I mean, if you have a QEC from there, this logical operator cannot be dealt with because your stabilizer just jumped over it. However, if you try to use this dynamically coupling sort of a SXDD stabilizer scenario, then you can actually push this contribution to higher orders in time in such a way that QEC can take over from whatever DD, it lives in. And well, and this is what we essentially just observation I had made for. And what we are trying to do now is actually doing this calculation I was talking about, of actually including the effect or actually the power induced by the code that well, it's kind of working progress. And ideally, we would like to do it to see what is the effective error rate when you actually produce a quantum error correction gate or unit error if you want. And trying to do like a full Hamiltonian analysis, but well, that is kind of wrong. But we are still doing it. And well, thank you very much. I hope you have some questions. Questions? You have a quick question. One of the nice things about quantum error correcting code is that if you have a sparsity or locality in your error model, it will be reflected in your code. That is your code will be nicer and smaller and everything will be better. But with the moves that you have, the scaling with the size of the number of qubits is exponential, right? It is, yeah, it is still exponential. Because if you look at the first order decoupling, you can exploit the locality of the error model. Yes. But if you want to go to arbitrary order, I don't think you can. You don't think you can? No, because, well, so what we're doing, the CDD thing, you see that even if, let's say you have one local error model, so regardless of, even in this locality, there would be a minus term at some point that will be at least the local, right? Where these are the distance of your code. So that term you cannot deal with even if you try to concatenate it more times in the case of the code. Because whatever, if you use your stabilizer, say as your code, as your operator, it will always jump over it. So that term will still keep that order D, T to the D if you prefer. So there is like, I mean, that's like an imitation you will have unless you use like the full stabilizer and logical thing. Time for one more question. Okay, if not, let's thank her order again. Thank you.
 Hello? This is good for everyone.  Okay, yeah. So we're, again, running a little behind here. So we're off set by a little  bit. Our next speaker is Harado Pazilva. He'll be talking about DD and Quantimera Correction.  Hi. So since we have been listening about the issue of combining Quantimera Correction  and maybe dynamic decoupling, would be some work we have been, some problem we have been  working on with Daniel and here at USC. So let me give you some motivation first of,  well, essentially this actually, before you mention, if you like DD Aquanism, this is  what we call SXDD, where X stands for whatever you want. But anyway, so let me give you some  motivation. Here you have your Quantimera Computer, which is ruled by some Hamiltonian  evolution, H of S, which I guess is a form of tissue when I went away. And I will just  flip so that. Yeah, so that's good. So we have our Quantimera  Computer, which is actually a computer with rule by some Hamiltonian. And then of course  we have the bath. And the bath is really, you can think of it as a big furnace, which  is trying to heat up your computer. And the problem, of course, is that there is this  system bath coupling, which is trying to essentially kill your computation. Fortunately, we have  seen that you can actually isolate your computer using Quantimera Correction techniques and  fault tolerance. And that is, of course, very good. But the problem is that if you're, the  heat, the amount of heat that is coming in or the size of these HSB is too large, then  suddenly fault tolerance is not too effective and it actually fails. Or you can also think  about this that maybe your quantum correction and your fault tolerance still works, but  then you require a lot of resources to do that. So I guess another thing is, well, can  you actually add another filter to this heat? Can you put another lower level of protection,  in this case, in the form of dynamical decoupling, that you can actually reduce the effective  heat that the Quantimera Correction sees in such a way that you can still either achieve  the fault tolerance that you could not before or actually reduce the amount of resources  you actually need. So let us start, like, going to the point, which is what the scenario  we are thinking of. So essentially, we have a quantum computer that's encoded in some  NKD code where N is the number of your physical qubits or the number of actual qubits you  need in your experiment. K says just the number of logical qubits and D is just the distance  or the capacity of how many errors, what is related to how many errors you can recover  from. So initially, we are going to consider the case where you have a Hamiltonian, which  has a part which is like purely bath. In reality, you can actually relax a bit this assumption  and say that it's not only bath, but it actually doesn't have to act as an entity in your system,  but maybe with some, unless operator. But for now, let's consider that this is just  an entity. And then you have the system bath Hamiltonian, which can have terms that act  only in the system or also in the system and the bath. But the point is that they are harmful.  There are terms that you really don't like. So in reality, this goes through some unitary  or some, let's say, we just call it tau minimum. And it will make sense afterwards why this  is a minimum. But this is just a traditional unitary evolution. You can actually quantify  some effective error rate via this expression, which is just a normal for your system bath  Hamiltonian times the time it takes to execute the gate. So what we want to do when we do  dynamic decoupling is actually, well, I want to take, even if I take longer, I want to  have a new unitary evolution, which has two distinct terms. The first one is this H naught  or H empty if you want. Well, depending on who you ask. But anyway, so this idea is that  this guy is harmless to your system. So if you think about it in terms of error correction,  it could be that this H naught includes, let's say, a stabilizer operator. So if it's a stabilizer  operator, you are pretty good, right? Because your information is, well, it's not harmed  by such operators. And you can actually now measure effective error rate again in this  scenario of some, when you have achieved, let's say, some dynamic decoupling of order  n. And then this, of course, is just a normal of this other term that you have there. So  the hope, of course, is that at some point you can show that the actual effective error  rate when you use dynamic decoupling, despite the gate or the operation taking longer,  then essentially it's smaller than the bare error rate. So this is all good. And this is  essentially what we would like to show. So there have been some work done in this direction.  And this was what Daniel was talking about this morning. So in this paper, let's call  it the NLP paper for simplicity, they showed that you could actually show enhanced fidelity  to the gates. And the main idea is that, well, you can think of applying simultaneously  dynamic decoupling gates on each of the qubits of your computer. And, well, this is, of course,  a very good idea. The issue is, of course, that for this to work, well, in principle,  you cannot, in this scenario, regardless of how local you assume your HSB to be, you  cannot achieve arbitrary order decoupling. And the main reason is that if you look at  the minus expansion, then you will see that eventually your qubits will give you, will  give rise to terms which actually commute with all your operators, and then you are  kind of in a bad shape. So to overcome this problem, part of, or in part to overcome the  problem, they introduced what it's called a local bath assumption. And essentially,  these guarantees that higher order mannus terms never gave rise to term, to actually  Hamiltonian, effective Hamiltonian terms that you cannot deal with, with higher levels of  DD concatenation. So you can actually, well, maybe the issue is that, of course, this  local bath assumption is not maybe as general as the most comprehensive, fault-tolerant  error models that you can think of. In any way, you can actually think, well, is there  any other solution to this problem? Can we actually go over the no local bath assumption  to that, or the local bath assumption, sorry? And you can, well, you can actually, there  is actually a solution, and it's actually a straight-forward solution. You can take,  you can take in the language of dynamical decoupling, you can take that n qubit power  basis, and, or either the generator or the full group, if you are doing CDD as you prefer.  And this is, of course, very good because you can achieve arbitrary order. However, there  may be a couple of caveats that, well, maybe they eventually may be important. The important  is, well, they, they growth exponentially as a function of 2n, which we call n is the  number of physical qubits. And not only that, but the poles look, the poles themselves,  although at the end you can, you might say, well, because I'm doing the whole group, at  the end they are applying effectively no operation at the end of the day. But every, every pole  itself is, may look as an error to the code. So it may limit in principle some integration  with other quantum error correction-based approaches. So what we actually want is, well,  we'll say we want to choose the right group, right? We want to choose a correct dynamical,  the right dynamical decoupling sequence in such a way that we need no extra locality  assumptions, that the pulses rely on the code, that they do not look like errors, and that  ideally we would like to get some shorter sequences to the full decoupling approach,  right? Of course, all these always only make sense if we can achieve, we can actually show  that our error rate is better, right? So let's, let us keep going. And well, the main observation  of course is that the magic of everything is just in the decoupling group, right? So  if you, maybe if you look at the problem, you say, well, if my group is too small, then  it may be that I cannot achieve arbitrary ordered coupling as was the case in NLP, or  I may not actually be able to decouple their Hamiltonians, which again, that would be a  problem, right? And if you, the group is too large, then as happened with the basis, then  maybe it's an hour kill, you can kill more terms that the one you need. And more importantly,  well, the shorter sequences, the better, right? This kind of the motivation. So the main tool  that we are going to use here is, is still that was introduced in a reference, how we  appear here shortly in the, it was introduced in the nested or dynamical decouplings in  NARU. And the idea is that you have the mutually orthogonal operator set. In this case, I will  also add that condition that is a generator set. And the idea is that there is a bunch  of operators, omega i, that square two identity and that either commute or commute or anti-commute  with each other. So this is like the main tool. And this is important actually because  you can formulate both CDD and NUDD in both, in these terms. And you can actually see that  you can formulate concatenated dynamical decoupling using as the base group, the group generated  actually by these, by this generator, by these moves. And you can actually use, do just plain  nested NUDDs the same, the same moves. So, so what is that we are thinking of? Well,  before we, I mean, reading the literature, people have thought about using the, just  the stabilizers of your, of your code as, as actual, as a decoupling group. And it was  a, it's a good idea, but again, you think that, if you think about it, when you do your  mind's expansion, higher order terms will make, give you a logical error. And this logical  error commutes with your stabilizer. So that is not good because eventually, even if you  try to go into N dynamical decoupling, to N order decoupling, that term will still be  there. So that is kind of a problem. However, if you actually add to these moves that a  set of power basis elements, like this is like a subscript, a separate script for the  logical version of this, is that encoded X and encoded C. And then you can actually  show that these moves is pretty, is pretty useful. You know, that is the super moves.  And the idea is the following, that you can still get this, if you write your dynamical  decoupling evolution, you say, well, this is my, what is, what I'm, what I actually  care about this, what is my H naught after the end of my dynamical decoupling evolution.  You can see that now the dynamical decoupling evolution is proportional to the stabilizers  of my group. And so this implies, of course, that this seems my, my, my code is chosen  such that the stabilizers stabilize it. Then this is exactly harmless to the, to the, to  my information. More importantly, I think is that if you recall that we were doing this  analysis, we assume nothing on Hsb. So in principle, Hsb itself could contain a logical,  sort of logical error type Hamiltonian. And this is actually, this Hsb term will, will  still be pushed to this, to that sort of decoupled part of your, of your evolution, right? So  this is highly beneficial actually. And so what have we gained with all these? Well,  in principle, we have, well, what we have gained is that of course there is, there is  no need for an extra locality assumption because essentially your, or the, or base dynamical  decoupling group is powerful enough that you can always decouple at every level of concatenation  group, like all the, all the terms you actually want to decouple. So there is no term that  is both un-decouplable and harmful by the next level of concatenation. So we can assume,  you can keep going, I mean, to do higher order decoupling as much as you want. And well,  for the end, you need the case, the, there is actually this proof that we are, we are,  we are working with Juan and Daniel and Greg. And then you can actually show that the same  decomposition induced by the, this imbues structure is actually very helpful. And you  can show that if you have the restructuring, you can go into the, into arbitrary order  decoupling with these, with these other scheme. So now if you see that the pulses we have  chosen are now, are now below and actually to the, to the group, right? And you can actually  also use them to be bitwise. So they're in principle not only experimentally friendly,  but they are transversal in the code. So for instance, if you were to think about CSS codes,  then your X logical operator, or biological operator is now bitwise and transversal. So  in principle, it respects your error model. So, and the fact that of course they, my  pulses do not lock errors, but in principle allows for other protections, the interaction  with other protection schemes. So what else have we gained? Well, let's check out, let's,  let's look at the cost of, in terms of a free time evolution, or if you want the length  of your, of your sequence. In fact, you can, you can check out that if the, the length,  the size of your moves is now, you can rewrite it. It would initially be the number of a stabilizer  plus two times the number of logical operators. But because of the stabilizer properties, you  can, you can actually rewrite it in this way. In the case where there is no subsystem, then  G is equal to zero. And then you see there is a small advantage here that you have n  minus key, essentially you get n plus K. However, maybe the more, and of course this is here  in this, here I'm showing the cost of fully decoupling and qubits. So you see that there  is actually a gain. And the more interesting case is perhaps when you have system code  and when you have a subsystem code and you can do, for instance, this is just the example  of the Bacon-Shark code. And you can see that actually the size of your, of the fully coupling  moves is actually, of course, two n squared because you have an n times n lattice. But  if you do that as an XED version, because you essentially only care about your number  of stabilizers, which is given by the expression and the whole number of logical generators,  because you only have one logical qubit and you only have two. So you see that you're  actually gaining an order of, well, a power here in this, in the size of the moves. And  this is, of course, even, perhaps more relevant if you think that this is actually the exponent  of some quantity regardless of what higher order decoupling sequence you use. So I guess  this is, well, this is better than the other. So we are still missing to show if we are  actually gaining something. So we are still not doing it. So maybe an observation I want  to make is that at this point where we have completed the distances in terms of the distance,  if you think about it, it's just the distance between the n qubit states, if you prefer.  However, in reality, we are not truly interested in the distance between the physical states,  the n qubit physical states, but the distance between the logical information is stored there.  So in principle, in our calculations, so this is just about the easiest bound we can find.  But of course, we are trying to work in just introducing ideal decouplers or ideal error  correction to mentally actually get the correct distance. So these sort of work in progress  at the moment, but nevertheless. So the problem is, of course, that thinking about this limitation  of calculation, thinking, I would say that the ideal error correction or the distance  between the logical information will be smaller than the one I'm going to show here, but this  is still a good proof of principle calculation. So the way of doing this is, well, we go to  the NLP results, which was, I think, actually this experiment, I think, maybe this cube.  So we essentially go to the algebra, and what they did is that they can compute the norm  of the system of the effective system, both of the effective and not Hamiltonian at every  level of concatenation, of DD concatenation. So you can do this trick, and then essentially  you can get a norm of this, the effective system, but at any level of concatenation,  and of course, multiplied by corresponding time of total length of the sequence at the  same level of concatenation. And the longest story short is, of course, that this is just  a power of HSB to some power, actually, it should be, I think, Q plus 1, but in the total  thing, but regardless. And the idea is, of course, that we want to compare the product  of these two quantities, which is actually this one with this one. So we actually go  ahead and do it, and for some particular code in this, we chose a Bacon-Schur code, because  we already know that it has a very good scaling, and this is what we get. So this is a plot  here of the log of the ratio we were considering before, and here we actually went through  the recursive relationships that were in the DynLP paper. This is like the first order  of concatenation, second order of DD concatenation, and third order. And you see that there is  actually a non-trivial interplay, depending between the degrees of, the different degrees  of DD concatenation for different set of values for J0, Taomine, and J, JSB, where, of course,  JSB is the normal physical HSB, and J0 is the normal physical Hamiltonian we had. So  here in this gray area, you can see here, it's essentially where there is no advantage  of using DD, and you're actually hurting yourself. So this sort of makes sense that as J0 is  larger and larger, then you lose your capability, but it's essentially related to the fact that  if J0 is too large, well, your system is evolving too fast, and DD loses its nice properties.  So maybe something I should say is that what we expect is that with the actual distance  measured, including the actual distance between the logical information, this graph should  well improve, right? But this is, of course, some speculation that requires some exact  calculation. So, well, this one point extra for us. The problem, of course, of this, the  fact that this is limited by the actual limitations of DD related to the normal physical, it's  actually a point for the system, but problem. And of course, we want to, of course, I showed  a memory sequence, and this will, of course, very, I mean, it's not terribly useful for  computation, but the idea we want to show, so in the graph that we showed before, it's  actually an implemented, it's actually a calculation based on these dynamic protected  gates that Daniel talked about before, where essentially you do, you append, instead of  making guess your gate, you put your dynamic open sequences, and then that's all good.  And then you can actually do the same, right? However, also another possibility, which is  actually the talk before me, which is pretty useful. And the idea is that you can actually  repeat the same, you can actually port the same sequences to our SXDD thing, because  essentially what we are saying is that, well, you have your favorite DD sequence and your  favorite method of doing gates, when instead of using pulses that belong to the PAULY,  the correct way or, well, the natural way of doing it within a code structure is just  use your elements of the code. And they have some very good properties, but they're experimentally  friendly, et cetera, et cetera. So I guess that's good.  So in conclusion, well, we have shown that there is actually no need for extra locality  conditions that pulses are in the code. And the shorter sequences, you have shorter sequences  that the fully coupling approach. So this is, this last point is actually what I was mentioned  before, that we are essentially not demanding anything on HSB. So if you think, for instance,  the computer has a system by Hamiltonian that looks like a logical operator, then you see  that regardless of how powerful, I mean, if you have a QEC from there, this logical operator  cannot be dealt with because your stabilizer just jumped over it. However, if you try to  use this dynamically coupling sort of a SXDD stabilizer scenario, then you can actually  push this contribution to higher orders in time in such a way that QEC can take over from  whatever DD, it lives in. And well, and this is what we essentially just observation I  had made for. And what we are trying to do now is actually doing this calculation I was  talking about, of actually including the effect or actually the power induced by the code that  well, it's kind of working progress. And ideally, we would like to do it to see what is the  effective error rate when you actually produce a quantum error correction gate or unit error  if you want. And trying to do like a full Hamiltonian analysis, but well, that is kind  of wrong. But we are still doing it. And well, thank you very much. I hope you have some  questions.  Questions? You have a quick question. One of the nice things about quantum error correcting  code is that if you have a sparsity or locality in your error model, it will be reflected  in your code. That is your code will be nicer and smaller and everything will be better.  But with the moves that you have, the scaling with the size of the number of qubits is exponential,  right?  It is, yeah, it is still exponential.  Because if you look at the first order decoupling, you can exploit the locality of the error  model.  Yes. But if you want to go to arbitrary order, I don't think you can.  You don't think you can?  No, because, well, so what we're doing, the CDD thing, you see that even if, let's say  you have one local error model, so regardless of, even in this locality, there would be  a minus term at some point that will be at least the local, right? Where these are the  distance of your code.  So that term you cannot deal with even if you try to concatenate it more times in the  case of the code. Because whatever, if you use your stabilizer, say as your code, as  your operator, it will always jump over it. So that term will still keep that order D,  T to the D if you prefer.  So there is like, I mean, that's like an imitation you will have unless you use like the full  stabilizer and logical thing.  Time for one more question. Okay, if not, let's thank her order again. Thank you.
Dynamical_decoupling_of_encoded_information_0_119.png Dynamical_decoupling_of_encoded_information_120_683.png Dynamical_decoupling_of_encoded_information_684_1115.png Dynamical_decoupling_of_encoded_information_1116_1475.png Dynamical_decoupling_of_encoded_information_1476_1535.png Dynamical_decoupling_of_encoded_information_1536_1871.png Dynamical_decoupling_of_encoded_information_1872_1991.png Dynamical_decoupling_of_encoded_information_1992_3539.png Dynamical_decoupling_of_encoded_information_3540_10607.png Dynamical_decoupling_of_encoded_information_10608_12155.png Dynamical_decoupling_of_encoded_information_12156_20099.png Dynamical_decoupling_of_encoded_information_20100_25979.png Dynamical_decoupling_of_encoded_information_25980_28871.png Dynamical_decoupling_of_encoded_information_28872_29927.png Dynamical_decoupling_of_encoded_information_29928_30047.png Dynamical_decoupling_of_encoded_information_30048_30131.png Dynamical_decoupling_of_encoded_information_30132_30971.png Dynamical_decoupling_of_encoded_information_30972_31031.png Dynamical_decoupling_of_encoded_information_31032_31079.png Dynamical_decoupling_of_encoded_information_31080_31295.png Dynamical_decoupling_of_encoded_information_31296_31655.png Dynamical_decoupling_of_encoded_information_31656_31775.png Dynamical_decoupling_of_encoded_information_31776_32039.png Dynamical_decoupling_of_encoded_information_32040_32339.png Dynamical_decoupling_of_encoded_information_32340_32613.png