Merken
Quantum Error Correcting: Codes for Locavores
Automatisierte Medienanalyse
Diese automatischen Videoanalysen setzt das TIBAVPortal ein:
Szenenerkennung — Shot Boundary Detection segmentiert das Video anhand von Bildmerkmalen. Ein daraus erzeugtes visuelles Inhaltsverzeichnis gibt einen schnellen Überblick über den Inhalt des Videos und bietet einen zielgenauen Zugriff.
Texterkennung – Intelligent Character Recognition erfasst, indexiert und macht geschriebene Sprache (zum Beispiel Text auf Folien) durchsuchbar.
Spracherkennung – Speech to Text notiert die gesprochene Sprache im Video in Form eines Transkripts, das durchsuchbar ist.
Bilderkennung – Visual Concept Detection indexiert das Bewegtbild mit fachspezifischen und fächerübergreifenden visuellen Konzepten (zum Beispiel Landschaft, Fassadendetail, technische Zeichnung, Computeranimation oder Vorlesung).
Verschlagwortung – Named Entity Recognition beschreibt die einzelnen Videosegmente mit semantisch verknüpften Sachbegriffen. Synonyme oder Unterbegriffe von eingegebenen Suchbegriffen können dadurch automatisch mitgesucht werden, was die Treffermenge erweitert.
Erkannte Entitäten
Sprachtranskript
00:00
yeah then the clicker Twitter director OK well if you thought yet yet of the great thing to look at that so thank you very much OK but well 1st of all I want to thank the organizers for the opportunity to that to be here and as as Daniel said I have recently left the university Washington and go here to Google has so if I make any mistakes is because I've been writing Java code solid for 5 months and and my brings completely wired different now and so anyways it's good to see familiar faces here it's also good to see nothing because that means they're young people really really exciting things I today I wanna talk about an hour codes for a for local bars but before I do that I I wanna think that story but also on a fake want to this technology also get there I wanna think Daniel for the invitation to come
01:19
here but my 1st paper that I ever wrote was in in constituting was in 1999 I wrote a paper in the journal Geology before that and this is that paper from that 1999 in which great about this paper can't tell here but this is error when I boldfaced every operator and write them will find things all of our operators early papers are boldfaced just discussed but luckily I think we overcame that difficulty of but the other the other thing I'd like to bring up as I I'll never forgive Daniel for 1 particular thing about that period of my life which is that when I was in grad school but in a time if you go back to the very beginning of Daniel's publication list you might that there's a different person listed the annually with our hamburger of course my last name is Bacon right before we published this paper he stopped using it we could have had begin hamburger Babar and so I'll never forgive him for
02:16
not allowing me to have a bacon hamburger paper if there's a very audience as a food item was last name and they wanna right paper together talk to me we can write something and and be great
02:26
but so I would talk about today talk about that time errorcorrection and I wanna talk about I how to make it local OK so I mean spatially local i in a nice way OK so here's our polymeric correct a quantum error correcting circuit and you know you have time money from left to right here I do some Hadamard that they're t look closely you can barely see the creation of some cats down at the bottom and then some measurement going on in this is just 1 big small portion of of the error correcting routine which which we all know it now
03:00
the question when talk about is how to fit this thing in experimentalist box this port taps doesn't quite fit of and in
03:08
particular I wanna think about the problems of this factor were gonna have to lay this thing out on some say to the architecture maybe 3D if you're really ambitious and in particular
03:18
this seems kind of daunting so here's a 1 of the very 1st and not the 1st but 1 of the very were 1 of the 1st US stabilizer codes every is ever discovered this this being code and remember their cracking procedure what you do is you for a 4 stabilizer codes is you measure these operators as a measure that you know you're a measurement which tries tries to project onto the plus one or minus one eigen values of the stabilizer operators and then given those measurements you can diagnose the error and correct it if you want to know but in this thing those operators are like S. 1 they have identities don't touch the 1st 3 qubits and then there's a policy on the last 4 right and then they're laid out like and if you think about this you know these these are measurements you trying to protect that that to achieve of this for operations operation and this is you know a little bit hard to do when you try to lay this on some substrates thank you please so it but and that you know if you look at this the encoding you know anything about this reasoning stinko you might know that it that kind of nicely on what looks like a flattened Q right so you know there's a face here and there's a place here in this a face here and these measurements can be made to maybe sort of around those spaces so it at a firstorder it's kind of nice in the sense that while these therefore Cuba operations you have to measure and we have to use SOS using Federer right but they're sort of at least laid out nicely right but the traditional way that we did Towards of thresholding fault quantum beauty
04:46
is to take that coat and then concatenated right and of course there are other ways to do that and 1 of the ways in the talk about hopefully is something today but if we concatenate the steam code here I've done it out in all its painful glory thank God for cut and paste and you know you have to measure the stabilizer operators which not only increase in weight right so this is just a 40 1 here right now we have 3 times 4 right so we have 12 Cuban operations but they started it spread out even further right so I have to measure you know cubits they're sort of a cross you know this is a part of the year and part of you part of you part of here and it grows and grows and this is in the fundamental barrier but it's kind of annoying especially if you can actually title leaders out on any sort of reasonable architect OK so that's
05:31
what really worries me the cat I should appear slightly larger here just getting worse and worse and worse Portet yes and put in another picture of sex
05:40
act as well we need more fat cats so
05:44
OK so that's that's sort of the state of the situation for concatenate codes as they as you can contact me more and more you know the that measure not bridge if you do get bigger bigger and while that's not a fun barrier and a nice trick to get around this it starts to get kind of dancing but there are some rays of hope I and in particular the codes that we have come to understand are very nice in this respect as surface codes and here what you do is you instead of measuring these you know seduce Concannon structure you have a code whose of single operators are more naturally local OK so we have these spot cat and vertex operators these for Cuba operators the measure the all sort of very close together a nice and you can imagine you know this is a little part of your ha where the does each of these different measurements and have to worry about fault tolerance and stuff and this but this is a very now well developed and and there's lots of amazing work going on studying and so this is rays of hope that
06:40
end but what we really like to do is find other codes that are like OK so make some definitions just so I can say some things that a sound rigorous but these are really just definitions that most of you our many of you know and so on and call things S local and s neighboring so we have a poly operators just the number of you know we Dreier poly operator like this steric here the number of these I operators which are not identities as the way 5 operator here right that's the way it's sort of the size of it and they were going to say it's something is an s local code right so as local code if there's that a stabilizer generators whose weights less than or equal s so the surface code that I thought said on the previous slide has has a is for local OK now this is using this definition of local the computer scientist like this does everything to do with spatial locality at this point right this just means that they have weak for OK they could be weight to over here in week 2 over here OK so at this point that that has nothing to do with with any sort of locality what were looked really looking for is what I'll call s neighboring but in D dimensions which is the you have some sort of regular lattice it does every right you know you can find around Hurry 1 actually define the has nice sort of structure and allows you to define something like a lattice right and then you're working about so that you know you wanna know sort of what the size of that radius is on that lattice that that operator operates on and that's that's well call s neighboring so they're all within a distance S and I've just leaving that they definition of distance just because it doesn't really matter to the service code for example to put on a lot the core class can be made the 2 neighboring into this is really what we're after in terms of codes we like in terms of spatial locality is is low as neighboring so cost 2 3 4 OK so this is the
08:27
this Rogers laments the end of the guy ever heard him say a negative word but here he is he's going to say why can't all the codes B. s neighboring into a 3 spatial dimensions so why what and why can't we find codes they're very much like the Surface Cohen we have examples of codes like that color codes etc. and 1 issue today is a new
08:47
for a class of codes that aura of very much in line with that's with that type of code no that's that's s local for some constant OK so here's the main result it says that that you take some code some stabilizer code can be a subsystem code ballistic nor that right now so you have in cubits physical qubits right you can encode take cubits into there and then this code has a distance d rights is the weight of the operator the smallest weight right that does something nontrivial on the encoded space right and that that then says that for every such code you can turn it into a new code that new code has some in some properties that are nice so 1st of all there's a bad property which is that now instead of you know I have Rigel coat with in cubits will in their turn to begin were begin is out of order in Square OK so you get a but load more a tube bits for want of a more technical terms but and what's nice about this code so so there's another thing years as a new parameter here's this means this is a subsystem Codenoll explained that means in a 2nd and there's some all new gage qubits here to the good things are that that that the distance of the code is the same in number of encoded cubits is the same as the original what's really nice about this new code is that it's spatially local it's s neighboring for some as constant say as a story you can you can always do that the cost of in data but you know as to be 3 or 4 in greater than 1 dimension so you can always take you have some code does any spatial structures like that concatenated code right I can take that code and I can turn it into a code which is spatially local OK and that's nice because that might help us when we're trying actually lay this out on a real architecture and this makes Mr.
10:36
writers are happy OK so how do we
10:40
understand this coats when we need order to get there so we'd stabilizer subsystem code so if you know stabilizer codes this isn't too bad I wouldn't do measure this con computing and then there's a little slide about spacetime locality ponder correction and antifraud altogether and blue you get the result 1st thing stabilizer subsystem codes OK so if you have n k destabilizer code right you obtain coding cubits and you have some distance to Union invisible cubits have to get a subsystem code out of this so the gives us the by the subsystem code wait it 1 way to think about it is just to take these encoded cubits right so we're coated some cubits and this is a stupid but let's say we don't care you know like I really only once or 1 qubit of of confirmation right so I do I can say why don't care what happens these other ones over here if it rains on them a course on I don't care I was just blown off right and they care
11:29
about K prime encoding cubits some they care about some of them and these ones over here I'm not going to care about what happens to them their current cubits so they mean that too physically operate on then you can just you know do 1 single X 1 singles you know what they are actually but you know there's some other logical operation that operates on a but you don't care about that operation because it just acts on the students so is the notion of a subsystem code of this paper in 2000 cool and as it does a great job explaining these new stabilizer subset so here's an example of them and so why a subsystem codes good you might say well you know I
12:04
had all these cubits I k of them but
12:06
I just use all k of them right like that's good it seems like throwing away cubits is a really stupid thing to do right Telek's realistic attitude is thrown away
12:14
but turns out that that's not true it turns out there is actually a
12:17
good reason to throw qubits and so here's a here's a a subsystem code so like any stabilizer code we have our stabilizer generators in this case we have 4 of them if you know the Shor code bill of partially familiar but a little bit tweet and they don't have these gage cubits these ones we don't care about their 4 of those and we have a logical qubit and if you stare about that for a little bit you'll notice that the logical qubits if you multiply by gage operators stabilize operators always stay at least wait for and tell much about the identity which we don't worry about right so module the gage this has a a distance right and you only have 4 stabilizes here that you need to measure and this has a so this the distance 3 code we need to measure these 4 stabilizes the need of measure fewer stabilizes and say the Shor which also has 9 qubits but there's an even need a property which is
13:10
that you can measure these operators in kind of a clever way by do either of those series of 2 Cuban measurements so the way you do this is if you go back from the previous slide there were gage cubits this is what gave you that is better gage cubit and then this thing in the middle here is a product of 2 gage cubits and stabilizer so those gage logical operators there was 1 here 1 here and then this 1 is a product of those 2 times as 1 so in order to measure as 1 what you can do is you can measure the stage cubic you measure this stage to that and they can measure this these 2 cubits here and take the product you get us 1 now when you do that for the operators Yeagley measuring like C 1 and C 2 on the 1 hand it's actually Z 3 0 commute with each other right so you sort of have to do this measurement here and get this result may do this once again be messing up the information gage qubits begin you don't care about that fact right so have engaged Cuba around allows you to take big stabilizer operators and shatter them into gage cubits right you know something that's still that's that's very local which is the stabilizer times did you and then put them all back together again up stabilize and those things don't have to commute with each other those those data measurements on of new at each other's longitudinal syndrome 1 and then some from 2 following that OK so this is why subsystem codes right you can you can break things up I don't the measure wait 6 operator now I only have to measure a series of 2 measurements and that's that's of an improvement OK so now I'm innocent eigen love more
14:43
about stabilizes in order to sort of I understand this in Italy about to sort of things you can do with with a such stabilizer subsystem codes there if the if you find playing with these codes you'll you'll get very you get very used to these moves but I Y X was elite point them out because I do them all the time I forget that I don't like them out so so you have a stabilizer a curve of subsystem coded has some stabilizes it has gage cubits is a logical qubits for the gage and it has a real logical operators the ones we care about right were sticking our information so these you should think about as you know some you know OK local operations on sums for some k right so some crazy real operate on physical all these are just encoded operations right OK so here yes there was a gage of logical now 1 thing you can do any such code is you can starting asking questions about I can turn the stabilizer into a logical operators I can take 1 of these and think about it a is the operator on over here a and I turn it into a logical operators now there's an extra logical operator here and do that I've had a defined X 0 which can commutes with this but commutes with everything else OK and you such as you can always perform such an operation in fact it's you know that's kind of the the funding is actually trying to figure out which 1 it is when you sitting around playing with there is a similar operation which is you can take a stabilizer and turn it into a gage operates as a banker's logical dangerous I'll use these moves as I sort of transformed from 1 code to the other so this is 1 code is a different code you could sort of more way around different codes to discover new and interesting coats OK so
16:22
that's that's subsystem stabilizer codes i in in about 7 minutes so that the next step in order understand these new codes is measurement based on computing course of always embarrassed to talk about measuring based on computing 1 robber Rossiter's so the audience but anyways I Robert you cannot pay attention right now as hot as measured based on computing work for those who don't don't remember so the idea is that you have some circuit appear anyone in act that circuit and weighted measure based on is very close to do should begin by creating this entangled state that's the socalled at graph state cluster states and and then you would you created this entails they start consuming reading the circuits emitted by making measurements to enact different things and then you start doing traditional measurements so these are all single qubit measurements on these bits as you sort of consumers entangled states and its presses the information through the system and tell eventually at the end you can do a measurement on the last 2 bits here say which has the readout of these of this case rate is entailed its state and that's you know sort of entangled on this graph and then you start doing single qubit measurements and you may have to adapt those as you go along appear on previous measurement results but you sort of push the information across the system and you can actor upon circuit to it it's it's very clever ship of trick OK so what's nice
17:48
about this also is that it turns out that the code initial entangled state is very local on this graph it's the stabilizer of these vertex operators little shown a 2nd which of Exxon operator the surroundings so the nice local stabilizer codes and the measurement you do also local right there just single qubit measurements OK so these are very on it you know what this graph is you know is is you know some lattice or something it this very sort of a nice local description of of of of how this works and that inspires sort of thinking about what's the code underlying this measure based on computer so all
18:24
introduce this by talking about a wire so measurement based on computing if you were going to do say a series of had a more dates that you could do that by making a line of graphs state and then doing X measurements on OK when you do is sort of work with that model but I'm going to talk about in terms of codes instead of talking about it in terms of the measurement baseball OK so in the beginning of this can start with the code bits that I is the most basic 1 for the system which is this vertex operator which I guess that is an X a cube and the and its surrounding ones have for every single vertex all those operators commute with each other they form a stabilized the generators of stabilizer group right and you're the plus minus of all these and that's the grassy on this 1 the line case of support so nice of all the stabilizes it's state there's a you know it's a code of right with which does encode cubitus in Q the state right so it's you know it's kind of boring in that respect but it's it's it's not really interesting coding of information and but it's but it's a state senator it can be describe and stabilize a formal this now do is emitted talk about a new cone want to do is I'm gonna take this 1st stabilizer the 1 that's over here xt and I'm gonna take that this exhi animal make it an encoder logical operations in a given X 1 so that's over here and then in order to make up a logical operation I need the you know I need that thing is in taking it with its with its encoded Z operation and that could be chosen to be easy III rights check this is I and II commutes with all these rights is the only way could possibly not add this 1 on this axis which is the next 1 so this is a code where you have 1 encoded achieve it distance 1 right because there's a weight 1 logical operators not that interesting from that perspective but but it is a code right and the interesting thing about this code to me is is well is that is that is that it sort of localized at the very lefthand side of this of this wire right at this point the code is that the the logical operator is you know you can get this x operation by measuring these 1st 2 cubits an XT or you can get Z E by measuring is the on the first one so it's localized all the way to the 2 last but modulo the stabilizer right it's also sort of localized elsewhere right so remember you can always multiply these operators
20:43
by stabilizer operators get a new logical operator pleasure the plus 1 eigenstates of these that doesn't change the value so I could measure this by measuring he's operators or for example I can
20:53
measure right here if I take S 2 times the 1 right that moves that z over a little bit and out the way to operator but sorta shifted over a little bit and so modulo the modulus analyzer it's you know it's sort of localized big about is the localized disease because you could get there but you can also moved over a little bit OK so now now comes the trick of thinking about subsystem codes so now I'm gonna do is I'm going to
21:21
define and you take this next 1 this X Z acts as to and unified engage operator they so I'm going to make it a gage cubits and in particular I have you know z 1 is that I have to find something which onsite commutes with it here's the X. operator and then choose this corresponds to when you're doing a measure based on the Curia measuring the X operations to push this what with information down a wire and so this is sort of a gage operator here that this is a gage cubic than our operate there's of course some people who were long no there's a problem with this slide which is that my logical operators now are correctly defined right have my stabilizer operators over here I have gage Cubitt easier to commute each other these commute with all these over here but these logical operators that I had for the previous slide don't you look at them they don't right there's a problem X 1 big X 1 the logical excellent from the logical operator right and commutes with X 1 from the gage operator so that's that's wrong z 1 I will tell you yes which 1 z widearea Z 1 and his area the 1 entered into they and so so that's wrong so I need to somehow update my code in order to make this correctly work to define logical operators and I can do that by multiplying this the logical operators over here by 1 of my previous stabilizes over 1 might stabilizes over here and when I do that I've actually done that 1 where I moved over a little right and it's X Z you now you can see that it really is sort of localized over here so now my x operator is is over here right and it sort of moved over now cost by multiplied by z 1 it moves over but that's a gage operation so technically can always move it back like that but in some sense adding this gage operator really shows the information a little bit to the right right so now now to actually measure z 1 for instance right I can but it's a top this point will the atomic site it's easier for me to do is like could could get continue at gage cubits right and do that by adding in these axes single qubit operators here and again and I commute with other operators and in a generator nice dates of gage operators doing that so I do this then I get already in what I'm gonna do is take all the vertex operators right except that 1 that I hold out the beginning in the logical operators and right at that first one and turn into a logical operator that would sort of leading separate right and I look at the top the group generated by these operators the single acts on everything except the last X of Fig. lectures on everything if at the last cube and then here's the stabilizer and he is at you know here is that the stabilizers that don't include that first one and these generate a bunch of gage qubits and logical operations are these x 1 and C 1 and you know is now these ones the ones in order to get them to commute with all these days operators over here sort of spread out across the entire thing cost this they include single qubit X operations so if you look at this you can just measure by you know you can you can you can you can operate you know multiply this dislodged operator by these gage operators and make this a single qubit x operation here this is still await 1 of right but the the logical information now is really sort of right it's it's sort of in this neat situation where if I really wanna measure this how I could do it I can measure a bunch of gage the which is at a single qubit operations right and you know I have to measure this last 1 because the right in add X to this last year it right but it or a measure that operation I can do that by a series of single qubit operations and measure this and a look around the logical of the muck around with you know with the gage qubits we don't care about that we do that a similar process here if you look around with against he was we don't care about that OK and this is this is better at this point of view but you know it exactly measurement is going getting in that you during measurements right and you may know that when you you know what you doing these measurements and you're you're pushing this thing along right you sort of think about how old the when you just do x measurements on this right you just sort of update whether you're you know how this thing is occurring in your measuring X operators plus or minus 1 and in the end the information comes out the other side and it's the same thing occurring here but this is just a sort of way to write this as a code OK a skip that 1 OK so let me skip ahead to something that's that's following tell your quick
25:49
and we'll get to the main results show you how it works this so I have to define something called the twister grasping which just means this making measurements so a measure based on computing you do measurements in this xy plane so doing that and can rotate the graph states so I can define a graph operator which you know has this rotated version of you know sort of X in the middle it has sought cosine their x plus y the rotate at the at the Cuban right and then all my measurements again the experiments just makes it simpler OK
26:18
so now there's this nice dictionary which is just coming from measurement based on computing which allows us to take a circuit any circuit which includes preparations and includes you know inputs that better not and not being prepared in the states and outputs right and then different different things like actual measurements here and transforms that into a circuit that you would do on this twisted graph state to do measurement based on unique to always do X measurements you reduce X measurements wherever there's an X in this constructed graphs awaiting a quantum circuit converted to a graph a graph will be labeled by angles which tells you the twist and single qubit exes which is where you should perform the single qubit expression OK so you notice for example when there's an output you don't measurement that last year right so that Cuban information will be localized here and here you know you are for forewarned measurements and so there is an X here so this is just the exactly dictionary you would do if you were doing measure of this column what what I do now is instead
27:16
of considering is as risk was kidding I'm gonna talk about this as a code so now I have these in this case there's no twisting of the word but I have a stabilizers for this graph state when there's a double block like this it means you don't include that stabilizes that's like that input that I had at the very beginning of that wire and then these are all single qubit axes K and these generate some group and they generate gage cubits and also stabilizes qubits state so this could touch screens and so if you don't measure the shooting what you do right as you prepare the
27:49
state you encoded information over here is input coming in here right you would have to sit on these 1st 2 cubits basically and then you'd perform these acts measurements and would propagate information across right and you push the information through and at the very end the LSAT information's localized to these last few bits over here with adding X is on and you wanna measure the OK that's how you would do it measure this quantity that's what these 5 steps are born do instead is instead of
28:17
doing the measure based on computing were just go look at the code generated by this set of operators OK and particular when you do
28:26
that what you find is that there are 2 stabilizes the pop out this as 1 s to 1 of these is that you know nontrivial cost output cubits the other ones not what this really corresponds to is if you go look at this circuit that idea here the people who are experts in in the circuits will know that what this is is this is as you know sort of a lot occurring on here in some way of 0 you're measuring operator so this circuit right here actually measures as easy stabilizer on these 1 and 2 cubits and that's explicitly corresponds to the fact that the stabilizer idea has a z here in a z here OK this 1 here has this weird property that it doesn't operate on on these output to that's what it corresponds to is that you can put in something here needed a measure and you know what that outcome is right you know your projection the plus 1 or minus 1 for this and that's basically occurring in the in the output of this stabilizer operator here now what's nice is is member these things like all these things together they form data cubits right this is a big highway operator right but you can measure it but via a series of of war weight operations right now in this case the stabilizer the end because you know these are days qubits a single is a gage Q. this is just a week to stabilize the operators not very interested in the sport right so but on the other hand you can measure it via a series of nice of our low operations a particular view measure these blue vertex operators you'll see that all disease cancel accept these ease of easeofuse last words so by measuring those those you know those gage cubits you could actually measure this full stabilizer here in particular you're gaining access to a measurement of the Z on these last 2 years then
30:16
and just to show you with the logical operators look like here they are you'll notice that the logical operators because you're now acting on you do you basically have this easy code occurring right you have a logical z that's a single qubit now you have a logical acts which is spread across here so there's a logical operator a logical X operator which actually has weight you know it's is distance to right you can't make this any smaller because you can't have him alive I X is here you can get rid of these but can carry these positional no x is up here and if you try get rid using vertex of receiving you can you can ever get rid of them you go around the paradoxical I take a cake and make them smaller and smaller OK so let me finish up
30:56
I guess is closer so this is the final inside and I'll show you the construction K so the final inside is so we had measured is con computing and now what we need to know what I really want is a war codes that local right so but 1 thing about contracts like I said is there's no fundamental barrier to the factor we have the measure this concatenated structure right like we can make circuits that's what things around in is very cleverly when you're doing faulttolerance right that you can make things everything local in space time right so you know these 2 distant cubits are operating on each other but you can swap them around and swap them back right and do this operation between these 2 you can swap them here to get this 1 that's that's distance to so if I you know if I have the any circuit or you know I mean the mountains A 1 A 2 dimensions my circuit goes on I'm I can always make the unitary is sort of only act locally on this lattice in in space time or so in some sense the locality issue but you know is really I have spatial dimensions and then 1 time I you know with time and I can make everything sort of by some local and so now I really only need to convert time and the space minor detail time into space but that's what measure this quantum computing that's right and this is this result about making a faulttolerant quantum computing local of these papers the meticulously provide an embarrassment but who is also in the audience here but talks about how to actually do that and when the requires next year's neighbors but that's actually not a big deal for this construction and you talk about OK so I'm almost
32:33
done is what everybody feels like I'm sorry you donkeys been overturned OK so here's what you do
32:40
so to construct this new circuit you take that code that you care about that in the eighties there you're starting OK and then you construct a faulttolerant syndrome measurements for that quantum circuits so here for example is a code you know Fawzi's use and and and for the Hillcoat right this is a circuit that actually does the measurement here you can see I prepare some cats so I prepared some cats and then I I do something in it and this isn't quite spatially local right sort of you know have a long wire here but you could take care of that so that's sort of just for illustration purposes we have this fault tolerance circuit in space and time case now what you do will you now convert that to what you would do if you're doing measure of its contribution
33:24
there's some weird things because like I said there's this input wires and output wires so you have sort of places where you don't include stabilizes right and don't do measurements that this over here and this is so and I've taken some liberties here if you look at this a long enough you'll see that sort of moved some things around using the simplification measurement based on unique but you can see is a creation of of the summit of operations between them and then it goes off to the side of that of course that sort of overlapped here crossed wires but if you do things nice with the actual value OK and now as you do is you say OK instead of considering this is measured based on computing think about this is the code OK and take all those x operators in that construction and take all the vertex operators in a construction you're missing some here in missing from X is here and look at the group generated by that it'll generate gage operations and it'll generate prat stabilizes politically correspond to measure the outcome and when you do that that the the the claim is that you end up with exactly a code who stabilizes have portions which adjust the stabilizes the Rigel code on these output units that's what we saw in that original little tiny construction it works here and the whole trek approving this whole thing is actually proving that that this thing in that giving you that the crack stabilizer of your original these cubits modulo gage operations and again this is nice story about in order to measure this these things can if you this is that a code to be really highway operators but the measure you can measure a series of gage operations with all spatially local cause all you're ever going to measure these things are measuring these these local operations right perhaps some local operations here and pushing them back right and you expects you note splitting up the stabilizer just like we did with the original code that I showed you say profit so what
35:18
happens is you get this factor of M squared but in blow up in the number of qubits you need for this and so that's bad right you get a lot more but you end up getting this on some s neighboring measurements so often up appear
35:33
there's so this is this is a property Google does a bad job I mean I did labeled for reuse and profit Amazon when these people have to do with but I guess it's because I did label for reuse the library reading prayers right here so there's but a U.S.
35:47
and so this but this this this constructions kind of all odd there's about things that everybody eyes that's about it what is widely default on syndrome measurement circuits that the reason you need that is because you need to maintain the distance of the code right so my concern the co without the fault faulttolerant a single circuit than there are low weight operators which accurate operate on the logical information so the fall tossed edition is basically used to maintain the distance of the code and you say well faulttolerant operations usually probabilistic they are like a cat do this creation year you may wanna regenerated what you do is you can't get to sort of assume you got the right outcome because you define yourself as being in the plus 1 eigenstate of those stabilizes the corresponding measurement operators you get she'd on nice way and there's the other question do these cos of thresholds I still don't know that was the answer that's true I suspect they do so but I don't know and then the question is how local can you make them the should be s neighboring actually make them well as local so you can make an OS locally can make always the weight of the it stabilizes could be made 3 local for all these constructions OK and I probably can be made to local though I don't know how to prove that and I think some of the results on the subsystem codes probably would push in that direction of ruling those out so these to be made 3 local and that's nice OK
37:06
so the consequence hopefully is that you have this you know this way taking any code laid out like Divinity measure based on computing and then you can talk about how you make a measurement of these of these operators to measure the syndrome which is distributed in on this 1 boundary over here and that should be hopefully useful because now you have local codes like the Surface toads or like like color codes and this is still in preparation with my student Johnson she and this is the product in working on Google's postlaunch in January so hopefully have time that finish that off
37:43
you don't which is still going along heroin see for there and severe in seattle please look them up and nor paying me and these were people who funded this research a long time ago
37:54
and that's it's in the test that says no cats were heard during this talk that they probably should thank you very right thank you Davis think everybody wants to come back with doing Google secrets so any questions for that Giselle'' go up Amelia exponentially at the secret but any other questions so you make those faulttolerant circuits local with swaps right that a you can have the emotion using swaps to get something that image of can of local from the from this so you need any need to do that careful swapping method may not appear to be a free OK so you have to to do the fossils so we're going from 1 B we're taking a 1D co construction and in space time you have next nearest neighbor operators so on the lattice that will be that of the things are just a little bit bigger than they should be so in that not like in that definition of local works out fine but only cause I use that definition of more questions for Houston it's not the weights 1 gage group operators public penalties that you know sort of general I understand that you're construction you have to because you map it to the measurement this quantum computing but how much penalty in general do you think that gives you a the mean how much how much penalty in terms of the that the learned and I mean that in in practice when you do you know if you try to do say Steen's code you end up with you know 70 Hubert's or something right so I haven't spent time optimizing it bites you know I I think that's a good question how to actually do it in a really nice way on a small thing that I don't know the answer that it's a good question terms you make the code word much bigger and you maintain the distance that occur so be a lot more errors if there's anything errors on all the key that's that's right did you have a very large gage group what would it be possible conceivably to turn some of those gage operators back stabilizer operators and at a distance of something like that you could I mean I think what's with so the and talk about this but that the most bizarre property of these codes is because you have some ETH cubits around what really happens is the distance along the time direction not really well defined for a operators because they're all module oldest the the the stage operators so what looks like a distance is really bad because there's always gage around you can't say anything about the threshold relief from that so if I were just if I were just thinking about the threshold without that gage degree of freedom I'd say this thing doesn't have a threshold because that gage freedom I don't think I can say that and because these are using fault on circuits that's why because may actually have think about think about spacetime fault tolerance which you doing is you know your circuit runs off like this and you're just randomly poking in year 1 of our models Ms. Renwick throw there's an there and if you look at the density of those areas across that circuits really bad right but yet it still gives us a faulttolerant result and so I think the same thing will happen here that's why I suspect as threshold OK I think we have to move on but before we do I wanna tell you do that if you come back I will change money back to right paper together it's brutal from fare and at the and of the
00:00
Stereometrie
Maschinencode
Twitter <Softwareplattform>
Selbst organisierendes System
Applet
Maschinensprache
Grundraum
01:18
Inklusion <Mathematik>
Videospiel
Nichtlinearer Operator
Rechter Winkel
MailingListe
Frequenz
Fehlermeldung
Gradient
02:25
Fehlererkennungscode
Quader
Schaltwerk
Sampler <Musikinstrument>
Stichprobenfehler
Ausgleichsrechnung
Quantisierung <Physik>
Quanteninformatik
Minimum
Digitaltechnik
Quantisierung <Physik>
HadamardMatrix
Computerunterstützte Übersetzung
Fehlermeldung
03:08
Qubit
Nichtlinearer Operator
Maschinenschreiben
Fehlermeldung
Bit
Stabilitätstheorie <Logik>
Maschinensprache
Nichtlinearer Operator
Ausgleichsrechnung
Codierung
Teilbarkeit
RaumZeit
Algorithmische Programmiersprache
Rechter Winkel
Eigenwert
Maschinencode
Nichtunterscheidbarkeit
Quantisierung <Physik>
Computerarchitektur
Prädikatenlogik erster Stufe
04:45
Nichtlinearer Operator
Fundamentalsatz der Algebra
Stabilitätstheorie <Logik>
Maschinencode
Gewicht <Mathematik>
Nichtlinearer Operator
QuickSort
Quader
Gewicht <Mathematik>
Rechter Winkel
Mereologie
Computerunterstützte Übersetzung
Schnitt <Graphentheorie>
Feuchteleitung
05:36
Nichtlinearer Operator
Fehlermeldung
Maschinencode
Klassische Physik
Prozess <Informatik>
Flächentheorie
Maschinensprache
Nichtlinearer Operator
Knotenmenge
QuickSort
Fehlertoleranz
Knotenmenge
Flächentheorie
Zustand
Maschinencode
Mereologie
Zustand
Computerunterstützte Übersetzung
Datenstruktur
Aggregatzustand
Feuchteleitung
06:40
Stellenring
Maschinencode
Stabilitätstheorie <Logik>
Punkt
Gewicht <Mathematik>
HausdorffDimension
Flächentheorie
Klasse <Mathematik>
Maschinensprache
Nichtlinearer Operator
Polygon
Term
HausdorffDimension
Gewicht <Mathematik>
Regulärer Graph
Flächentheorie
Lokalität <Informatik>
Maschinencode
Nichtunterscheidbarkeit
Generator <Informatik>
Datenstruktur
Informatik
Nichtlinearer Operator
Radius
Stellenring
Systemaufruf
Nummerung
Codierung
QuickSort
Rechenschieber
Generator <Informatik>
Dienst <Informatik>
OfficePaket
Verbandstheorie
Rechter Winkel
Wort <Informatik>
Speicherabzug
08:44
Resultante
Stabilitätstheorie <Logik>
Maschinencode
Bit
Gewicht <Mathematik>
HausdorffDimension
Flächentheorie
Physikalismus
Klasse <Mathematik>
Maschinensprache
Term
RaumZeit
HausdorffDimension
Maschinencode
Datentyp
Datenstruktur
Gerade
Qubit
Nichtlinearer Operator
Parametersystem
Kategorie <Mathematik>
Eichtheorie
Nummerung
Quadratzahl
Last
Rechter Winkel
Computerarchitektur
Decodierung
Ordnung <Mathematik>
10:38
Qubit
Resultante
Nichtlinearer Operator
Maschinencode
Stabilitätstheorie <Logik>
Gewicht <Mathematik>
tTest
Stellenring
Computerunterstütztes Verfahren
Maschinensprache
Codierung
Eins
Teilmenge
Rechenschieber
Unterraum
Prozess <Informatik>
Rechter Winkel
Maschinencode
Ordnung <Mathematik>
MinkowskiMetrik
12:03
Qubit
Nichtlinearer Operator
Bit
Maschinencode
Stabilitätstheorie <Logik>
Decodierung
Mathematische Logik
Kategorie <Mathematik>
Eichtheorie
EulerWinkel
Eins
Unterraum
Generator <Informatik>
Twitter <Softwareplattform>
Rechter Winkel
Maschinencode
Nichtunterscheidbarkeit
Generator <Informatik>
13:09
Resultante
Stabilitätstheorie <Logik>
Maschinencode
Subtraktion
Mathematische Logik
Punkt
Gewichtete Summe
Maschinensprache
Information
Nichtlinearer Operator
Mathematische Logik
Eins
Eigenwert
Maschinencode
Biprodukt
Kurvenanpassung
Qubit
Nichtlinearer Operator
Reihe
Stellenring
Eichtheorie
Biprodukt
Kommutator <Quantentheorie>
QuickSort
Rechenschieber
Rechter Winkel
Information
Ordnung <Mathematik>
16:20
Qubit
Resultante
Stellenring
Bit
Stabilitätstheorie <Logik>
Graph
Logische Schaltung
Einfache Genauigkeit
Physikalisches System
Maschinensprache
Computerunterstütztes Verfahren
Nichtlinearer Operator
Bitrate
Knotenmenge
QuickSort
Graph
Eigenwert
Verschränkter Zustand
Theoretische Physik
Maschinencode
Digitaltechnik
Information
Ordnung <Mathematik>
Aggregatzustand
17:46
Stellenring
Stabilitätstheorie <Logik>
Maschinencode
Bit
Mathematische Logik
Decodierung
Gewicht <Mathematik>
Punkt
Gruppenkeim
Kartesische Koordinaten
Metastabilität
Maschinensprache
Computer
Ungerichteter Graph
Nichtlinearer Operator
Mathematische Logik
Term
Eins
Graph
Knotenmenge
Informationsmodellierung
Theoretische Physik
Maschinencode
Generator <Informatik>
Gerade
Drucksondierung
Qubit
Nichtlinearer Operator
Graph
Logische Schaltung
Reihe
Einfache Genauigkeit
Physikalisches System
Knotenmenge
Kommutator <Quantentheorie>
QuickSort
Generator <Informatik>
Eigenwert
Gruppenkeim
Verbandstheorie
Verschränkter Zustand
Rechter Winkel
Würfel
Codierung
Information
Decodierung
Ordnung <Mathematik>
Aggregatzustand
20:41
Eigenwertproblem
Nichtlinearer Operator
Stellenring
Stabilitätstheorie <Logik>
Bit
Mathematische Logik
Decodierung
Mathematisierung
Stellenring
Maschinensprache
Information
Nichtlinearer Operator
Mathematische Logik
QuickSort
Gruppenkeim
Rechter Winkel
Maschinencode
Restklasse
Generator <Informatik>
21:19
Resultante
Web Site
Stabilitätstheorie <Logik>
Maschinencode
Bit
Mathematische Logik
Prozess <Physik>
Punkt
Versionsverwaltung
Gruppenkeim
Kartesische Koordinaten
Ordinalzahl
Computerunterstütztes Verfahren
Nichtlinearer Operator
Mathematische Logik
Kubischer Graph
Eins
Graph
Knotenmenge
Maschinencode
Generator <Informatik>
Ganze Funktion
Modul
Qubit
Nichtlinearer Operator
Multifunktion
Sichtenkonzept
Graph
Reihe
Eichtheorie
Einfache Genauigkeit
Winkel
Knotenmenge
Kommutator <Quantentheorie>
QuickSort
Rechenschieber
Eigenwert
Flächeninhalt
Würfel
Rechter Winkel
Information
Ordnung <Mathematik>
Instantiierung
26:17
Subtraktion
Maschinencode
Stabilitätstheorie <Logik>
Gruppenkeim
Aggregatzustand
Ungerichteter Graph
Computerunterstütztes Verfahren
Nichtlinearer Operator
Graph
Arithmetischer Ausdruck
Quantenschaltung
Funktion <Mathematik>
Touchscreen
Qubit
Schießverfahren
Graph
Winkel
Einfache Genauigkeit
pBlock
EinAusgabe
Codierung
Ordnungsreduktion
Quantenschaltung
Digitaltechnik
Wort <Informatik>
Information
Aggregatzustand
27:48
Nichtlinearer Operator
Bit
Maschinencode
Ausbreitungsfunktion
Computerunterstütztes Verfahren
Information
EinAusgabe
Nichtlinearer Operator
Knotenmenge
Menge
Codierung
Eigenwert
Menge
Rechter Winkel
Maschinencode
EinAusgabe
Information
Aggregatzustand
28:24
Qubit
Nichtlinearer Operator
Maschinencode
Stabilitätstheorie <Logik>
Mathematische Logik
Gewicht <Mathematik>
Sichtenkonzept
Benutzerfreundlichkeit
Kategorie <Mathematik>
Reihe
Eichtheorie
Mathematische Logik
QuickSort
Gruppenoperation
Eins
Knotenmenge
Gruppenkeim
Gewicht <Mathematik>
Rechter Winkel
Digitaltechnik
Restklasse
Projektive Ebene
Wort <Informatik>
Funktion <Mathematik>
30:53
Resultante
HausdorffDimension
Maschinensprache
Computerunterstütztes Verfahren
Lokalität <Informatik>
RaumZeit
Fehlertoleranz
HausdorffDimension
Schwellwertverfahren
Datenstruktur
MinkowskiMetrik
Feuchteleitung
Nichtlinearer Operator
Konstruktor <Informatik>
Fehlermeldung
RaumZeit
Stellenring
Quantencomputer
QuickSort
Teilbarkeit
Quantisierung <Physik>
Design by Contract
Quantenschaltung
Verbandstheorie
Rechter Winkel
Digitaltechnik
32:37
Stellenring
Maschinencode
Stabilitätstheorie <Logik>
Gruppenkeim
Computerunterstütztes Verfahren
Nichtlinearer Operator
Nummerung
Fehlertoleranz
Knotenmenge
Einheit <Mathematik>
HausdorffDimension
Quantenschaltung
Maschinencode
MinkowskiMetrik
Funktion <Mathematik>
Nichtlinearer Operator
Konstruktor <Informatik>
Untergruppe
Physikalischer Effekt
RaumZeit
Logische Schaltung
Reihe
Eichtheorie
Umsetzung <Informatik>
EinAusgabe
Knotenmenge
QuickSort
Quantenschaltung
Generator <Informatik>
Rechter Winkel
EinAusgabe
HeegaardZerlegung
Digitaltechnik
Computerunterstützte Übersetzung
Ordnung <Mathematik>
35:15
Qubit
Kategorie <Mathematik>
Prozess <Informatik>
Rechter Winkel
Maschinencode
Programmbibliothek
Nummerung
Teilbarkeit
Lesen <Datenverarbeitung>
35:47
Eigenwertproblem
Resultante
Maschinencode
Stellenring
Gewicht <Mathematik>
tTest
Maschinensprache
Computerunterstütztes Verfahren
Richtung
Flächentheorie
Maschinencode
FAQ
Default
Konstruktor <Informatik>
Nichtlinearer Operator
Multifunktion
Schwellwertverfahren
Logische Schaltung
Biprodukt
Codierung
Randwert
Rechter Winkel
Digitaltechnik
Information
Binäre Relation
Computerunterstützte Übersetzung
Brennen <Datenverarbeitung>
37:41
Stabilitätstheorie <Logik>
Bit
Maschinencode
Gewicht <Mathematik>
Betragsfläche
Gruppenkeim
Gradient
Maschinensprache
Term
Stichprobenfehler
Richtung
Fehlertoleranz
Freiheitsgrad
Informationsmodellierung
Theoretische Physik
Bildgebendes Verfahren
MinkowskiMetrik
Softwaretest
Konstruktor <Informatik>
Nichtlinearer Operator
Schwellwertverfahren
Kategorie <Mathematik>
Güte der Anpassung
Fakultät <Mathematik>
Stellenring
Quantencomputer
ARPANet
Dichte <Physik>
Gruppenkeim
Verbandstheorie
Flächeninhalt
Gruppentheorie
Rechter Winkel
Digitaltechnik
Wort <Informatik>
Computerunterstützte Übersetzung
Schlüsselverwaltung
Metadaten
Formale Metadaten
Titel  Quantum Error Correcting: Codes for Locavores 
Alternativer Titel  Subsystem Codes for Locavores 
Serientitel  Second International Conference on Quantum Error Correction (QEC11) 
Autor 
Bacon, Dave

Lizenz 
CCNamensnennung  keine kommerzielle Nutzung  keine Bearbeitung 3.0 Deutschland: Sie dürfen das Werk bzw. den Inhalt in unveränderter Form zu jedem legalen und nichtkommerziellen Zweck nutzen, vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. 
DOI  10.5446/35327 
Herausgeber  University of Southern California (USC) 
Erscheinungsjahr  2011 
Sprache  Englisch 
Inhaltliche Metadaten
Fachgebiet  Informatik, Mathematik, Physik 
Abstract  In quantum error correction quantum information is encoded across multiple quantum subsystems in such a way that one can diagnose and fix the most likely errors that occur to the system. This error correcting step is achieved by performing a measurement that does not disturb the encoded quantum information but does diagnose what error has occurred on the system. These error diagnosing measurements are often, but not always, of observables that are nontrivial over nearly the entire quantum system containing the encoded quantum information. The exceptions to this rule are topological and color quantum codes where the diagnosing measurements involve only a small number of spatially local subsystems (that is, involve only measurements over a constant sized neighborhood on some Ddimensional lattice.) These spatially local codes are much better suited to most realistic physical implementations of quantum computers. In this talk I will describe work (joint with Jonathan Shi) that shows how to convert a large class of quantum error correcting codes, all stabilizer codes, into spatially local codes. These codes are subsystem codes derived from measurement based quantum computing and have the same distance and rate as the original code, at the cost of using more qubits. The best of these codes have distances that scale as an area in two out of three spatial dimensions, and have illdefined distances in the remaining dimension. 