Bestand wählen
Merken

Quantum Error Correction and Quantum Error-Correcting Codes

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
the OK so the 1st thing is you have to be able to find the microphone the so I like to join Daniel in welcoming you all to USC and to this conference but when I volunteered to give the 1st hockey I wasn't allowing for 2 things 1 is that of being the 1st talk I would be operating on very little sleep and not enough caffeine and the other is
that of course it it is incumbent on me to set the tone with a dynamic exciting presentation and of course there's nothing that helps people stay awake like listening to a lecture on quantum error correction but but no doubt your reaction when hearing there was going to be a 1 hour tutorial on Quantum error-correcting codes was the same as mine which is what what will we do with the rest of the remaining 45 minutes but when I started to write down all of the stuff that I really
either I realize that maybe my problem was actually the opposite and we may be here well into the night I'll try to keep to time however with the help of our friendly moderator OK but the 1 thing that's really working in my favor here is that 95 per cent of you if not 99 per cent already know everything that I'm about to say so if you do you should feel free to to take a nap for the next hour and then wake up when Andrew and all will will get up to give the tutorial on on fault tolerance so this is what I'm a talk about 1st What is Quantum Error Correction what's a quantum error I'll look briefly at how classical error correcting codes work because that's really the inspiration that led to the ideas of quantum error correction Quantum error-correcting codes but I'll look at some of the what I would say misconceptions about how the peculiar properties of quantum a case prevent error correction from being possible and then look at the examples of the the the 1st quantum codes to be discovered from those I will abstract this structure the general structure not completely not the most general structure but a very general structure for a quantum error correcting code but that will then lead me to the class on which the overwhelming amount of work in this field has been done which is that the class stabilizer codes and show their connection to classical linear codes is a little arrow in the middle of my talk I then I'll talk about how 1 designs the circuits to measure the error syndromes that are used in correction and also to encode and decode quantum information for many people they don't worry about exactly how encoding and decoding done but in certain areas like quantum communication this is very important even within in fault tolerance where you never really decode the use of encoding circuits is is often very helpful in designing counselors and things like that I'll say at a very little amount about the phenomenon of generous which is peculiar to quantum error correction and had no no real practical analog in classical error correcting codes and finally I'll I'll just say a a very small amount about the significant generalization of what am talking about in these points which is the operator were subsystem quantum error correcting codes so what is quantum error
correction and the question here really is what is a quantum error a quantum error it is obviously something that arises in the operation of say a quantum computer information from processing protocol which is undesired include disturb the outcome and of course the errors operations themselves are subject to the laws of quantum mechanics only certain things are allowed in the 2 most natural possibilities that would leap immediately to mind are either unitary errors in which we're trying to do some evalution but our Hamiltonian is not exactly what we think it is or is too strong to weak operates 4 different links of time so for and then decoherence due to the interaction with the environment and in both of these cases we can abstract away of the process that were describing as the state that we want side here being multiplied by some operator so this operator could be a unitary operator which represents the difference between the evolutionary want evolutionary get or it could be a a 1 term out of a Krause expansion for a C P P map now this is not completely general but it does include the larger the effects that we worry about in quantum computing so we're trying to correct the errors of that time and our model is going to be classical error correcting codes Sony Classical error correcting code will imagine that our system consists of bits and the canonical error that we could get would be a bit flat either 0 becoming a 1 or 1 becoming 0 so for a very simple error model the binary symmetric channel you could have every bit have a probability P of being flipped and so after about 1 over p steps in a bid would be essentially random lies they get around that problem what's used and has been known for a very long time is redundant coding so the simplest kind of classical error correcting code is just to make multiple copies of each of the bit so a very simple example we could just keep 2 copies so represents 0 and 1 by 0 0 and 1 1 and that if an error happens in flips 1 of these that's will get 1 of these pairs U 0 1 a 1 0 which should never arise and if the system is error free so if we ever see 1 of these 2 pairs then we know an error has happened so this is error detection the error detection is all you need for certain purposes of for instance in in communicating over the Internet often all they do is is added parity check and check whether the the parity check that has been flipped or not if an error is detected then they just send the information to get but that's not going to be good enough for most of what we're doing but classically you can just add 1 more copy and you get the simplest quantum error correcting code the 3 bit repetition or majority rule code so if any 1 of these 3 bits gets let we can look at the the 3 bits and take a majority of us so there's only 1 0 then we assume it was 1 1 1 if there's only 1 1 we assume that it's 0 0 0 so
from this single example I will now extrapolate and derive all of classical coding theory in brief what are the properties of these codes have 1st information is stored redundantly across multiple bits now this is really based on the fact that I'm assuming that errors are local errors that individual bits reflect Of course I can be more general than that in assume some broader class of possible errors that might include correlated areas for most of this talk I will assume that noise is local but 1 can make very similar arguments starting from any and naturally occurring sense of errors so if information but if errors a local then we want to spread the information across multiple bits so no single bed asking sorry information we can detect errors by having only certain code words allowed only certain strings of bits are allowed if we see anything other than those we know an error has occurred so that error detection and if we want actually correct we would like the code words to remain distinct even after an error has occurred so with only 2 copies of course if we
see a 0 1 0 1 0 we don't know if we started from 0 0 or 1 1 but with 3 copies we do
of course of 2 errors occurred then we would be correct wrongly and that brings us to the final point which is the limitation of error correction through error correcting codes we can't correct every error why because the difference between an error in an operation is entirely in our mind in error is an operation that we didn't want to do whereas operate operation that we did want to do but if you could have any possible error then your code word to be transformed into anything including the code words so we can never do more than correct some set of correctable errors It's always limited in what we like to do is to design our code to correct some particular set of errors that we consider likely or focus so we wall 1 our theory of quantum error correction to work in the same way but quantum information has some restrictions the classical information does not have that may complicate just reproducing this kind of structure so these were the questions or objections that were raised very early as a theory of quantum error correction was just coming into existence but many people said quantum error correction should be impossible because of the properties of quantum information so what are these properties famously there's no cloning a general quantum state cannot be copied it everyone well not everyone but many people said well you need to copy information in order to do redundant coding you can copy the quantum information therefore quantum error correction is impossible QED follow if we could get past that we have an additional issue which is we would like to preserve not just individual code words but arbitrary superpositions of in quantum states to make use of the power of a quantum computer we would really like to be able to operate up on arbitrary superpositions of our code words when you measure to detect whether an error has occurred you might destroy that superposition then out bit flips are discrete set but the number of possible operators they can multiplier status continuously in the so it seems like they're vastly more possible errors in quantum mechanics and in the classical digital information it in fact but is this problem that makes analog computing a and ineffective technique compared to a digital computer in analog computing use continuous quantities to represent the quantities of your computation but then you have this problem that a small errors in undetectable what's the difference between doing exactly the rotation of that you wanted and doing a rotation by some slightly different angle follow and that many of the people who claim the quantum computing can possibly work make this analogy to analog computing and finally bit flips bits can be flipped in any water but in quantum mechanics in addition to the continuum of errors the also community yeah so complete I observables they could be disturbed by different kinds of errors so this seems like a pretty serious list of obstacles and I it 1 might not be blamed for throwing up one's hands and say well quantum computing it's a nifty idea but require you to be able to see things perfectly and we live in an imperfect world so anyone who's been through the recent Winstorm knows how imperfect the world can be of and I was a skeptic myself in the very early days so this is like my moment of confession here but but fortunately I was wrong along with all these other people so I don't normally a feel relieved at being wrong but this is 1 case where where I
do so let's look at these objections at least the the the Tomb of initial ones 1st do we actually need to clone quantum states to do shit to do code and the answer is that we do not know if you think about it a classical bits 0 want verses 1 and 2 code 0 0 0 vs. 1 1 1 contain exactly the same information so we haven't made of of a copy of an arbitrary state when we do an encoding of this type so to put that in a different way that 1 doesn't normally see it if you think of a state of a bit as not being a value 0 or one but is being a probability distribution over the possible values 0 and 1 classical probability distributions also cannot because if you have only 1 copy of a system in a probabilistic state you can't create another 1 in the same probabilistic state that doesn't stop people from doing classical error correction and while I quantum status same as probability distributions there it turns out that this objection does not stop quantum error correction what about superpositions so classically when we wanted to check if an error occurred we looked at our code word and we saw if it was 1 of our lab coat with 0 0 0 or 1 1 1 or some code word containing an error but corner mechanically that would be a bad thing to do because if we had a superposition of 2 codewords we would destroy it however it turns out that actually measuring the individual bits is not necessary even classically to do error correction instead we can measure a series of parodies the tell us whether or not an error has occurred without actually telling us the value of the data were trying to protect so to take a simple example here if we look at the parity between the 1st and 2nd bit and between the 2nd and 3rd bit 3 0 0 0 both of those parities are 0 those 2 bits of the said and the same is true for the code word 1 1 1 the parrot those 2 parities are 0 in that case so if an error occurs say on the middle bit taking us 2 0 1 0 4 1 0 1 those 2 parities are both flipped and we can tell which error occurred just by knowing the values of these 2 parities without needing to know what the actual code word is that classically when we measure something like this we generally do it by measuring the individual subsystems the individual bits but quantum mechanically we don't have to and we'll see shortly a circuit that allows us to measure these parities without measuring the underlying data so if you do a well-designed code with a well-designed method of measuring these parities you can correct errors without having to measure the encoded information so we'll see how this works in the very simple code this is really just the same classical repetition code so we're protecting only against bit flips now what's the quantum equivalent of a bit flip is a I'm not operation multiplying by a Pauly X operate so this operator takes the basis states 0 to 1 in the base state 1 2 0 and we do encoding by embedding this system this single qubit state in a state of 3 so here we have our stated that we want to protect it we have 2 extra qubits that start in the state 0 what we call hands solar or ancillary bits we then do a unitary transformation which takes us to this entangled state of the 3 beds we haven't copied side this is in 3 copies of this state and this is in fact it entangled state that contains the same information so no quoting doesn't doesn't apply quantum circuit that does this encoding we just to to control knots from information Cubitt onto our 2 and so as in the output state is the encoded state we want now if a single bit flip occurs say on bit 1 then we get a superposition of 2 other states a 1 0 0 and 0 1 1 and similarly if we have bit flips on the other 2 bits we have 2 other possible states that will result and an important thing to notice is that our original state in each of these 3 states containing an error are all orthogonal to each other so our state here lives in some 2 dimensional subspace of the International hilbert space of 3 qubits and these 3 states live in 3 other 2 dimensional subspaces each of which is orthogonal to our original space and to each other to figure out of an error occurs though we have to do something cleverer than measuring these 3 beds because as soon as we do that we destroy the state that we're trying to preserve the so what we do instead would step we wanna measure these parodies and here's a circuit that does that so again we're using control knots we bring into ensellure bits but we do a control not from the 1st 2 bits under the 1st sense of it The control not from the 2nd and 3rd bits onto the 2nd answer like and then we measure them in the computational basis if we get 0 the parity of these 2 that's a 0 if we have 0 here the parity of these 2 that's a 0 otherwise we could get 1 here or here so there's 4 possible outcomes to this measurement they tell us the value of these 2 parity bits which tells us if either no error has occurred or a bit has been flipped and which did that 1 2 or 3 so here 2 key components for a quantum code 1st we have to be able to measure the error syndromes that is these parodies and this is the information that tells us what error has occurred we want to measure that and no more than that the 2nd thing is to correct the errors once we've made these measurements we can just do a unitary transformation on whichever of the 3 bits was flat the X gate is a unitary transformation so we can do that conditioned on this measurement outcome now already we've gone beyond what a
classical what the same classical code can do this classical code protects classical information but we've seen that we can use the same code to protect arbitrary superpositions and in fact we can do more than that suppose instead of a simple bit flip we apply 1 of these continuum of operators that is an X rotation on a single queue so it acts rotation is equivalent to turning on a Hamiltonian proportional to x for some length of time and we can expand this operator out as a superposition of the operators I and acts if we apply that operator to say the 1st qubit of our code where we get a superposition of 2 states 1 is original correct state and the other is a state with a single bit flip on the set on the 1st Cuban because this is a superposition
and those states are orthogonal when we do this measurement we will see either
this state or this state with probabilities cosine squared and signs where and if we see this we can do that apply the correction if we see that we do nothing there were left in both cases with aid a system having no errors so that in fact not only can this correct bit flips it can correct arbitrary excitations and more than that it can actually correct any linear combination of the air operators in this correctable set so any linear combination of the identity as a single exon bits 1 2 or 3 a represents an error that this code can correct so that flips are all very
well but of course on mechanical systems have many more degrees of freedom than just the values of the beds are for instance we could have faced flats where we flip the relative phase between this 0 on 1 components of the qubit this is the same as applying as the operator and we can protect against this kind of error in exactly the same way we protected against bit flips only now instead of encoding our information in the computational basis we encoded in the accesses where pluses 0 plus 1 and minus A 0 minus 1 we
can encode that using essentially the same circuit just applying ahead of Margate on each of the 3 qubits at the end that switches us between the
easy and the ax basis and we measure the syndromes again using a
circuit exactly like this only if I had a mod before and after each of these controls to switch from the X. basis to the z basis just long enough to do the Controlled not and then we switch back so we can protect against phase
errors in exactly the same way we can protect against bits that there's so that's all very well but neither this code or the 1 we saw before can correct against both bit-flip and phase-flip errors and the 1st person to show how to do that was Peter Shor followed very soon after by an interesting but will see his covered but he assure fix this problem by way of a technique called concatenation so he constructed a coding 9 keywords this code has 3 subsystems and the structure of it is the same as the structure of a phase flip code so we have a 0 plus 1 for the logical 0 state and 0 minus 1 but each of those that's now is itself protected by a bit flip code so is encoded in 3 Q for a total of 9 and this code can protect against an arbitrary of phase error on any of the 9 qubits it can also protect against an arbitrary X there are in fact thinking protect against up to 3 1 on each of these triplets but because it can protect against both the phase that and a bit flip error can also protected them happening to a single qubit which is the same as a Y so a poly Y is just basically Z times acts since it can protect against wise pansies and obviously the identity which is nowhere at all but we can protect against an arbitrary superposition these form a complete basis for all 1 qubit operators so this code can correct any single cubic with was the 1st the code found they could do that so from these
examples I will now do the same thing and deduce a general structure for Quantum error-correcting codes it turns out that what I write here is not completely general we can generalize it in a number of respects which I will say as we're going along but 1st of all area of Quantum error-correcting code is a subspace of a larger Hilbert's pets the the code space so in in the 1st example it was the subspace spanned by 0 0 0 and 1 1 1 OK it has to be a subspace because we need some room if you will of some extra redundancy with each character right the con error correcting code we can associate a set of correctable errors but now in fact actually for a given code there are often multiple sets that could be a set of correctable errors for that not so when I talked about the bit flip code it corrects against bit flips but it's also a code that would correct against an arbitrary why air the phase flip code protects against the sea areas but it could also protect against an arbitrary wise the user can correct against both and x error and the wire you have to choose so when we design a code were designing it and associate a particular set of correctable errors now each error in that set will then have map the code space this subspace to another subspace which is orthogonal to that original subspace and we want the subspaces to be orthogonal to each other for each of the areas in tractable set now this is something that's a little too narrow here they don't have to be exactly orthogonal and and as we'll see later with the phenomenon that the generous it isn't actually necessary that every error have a distinct airspace but this is the basic idea when a correctable error occurs the state become becomes mapped to another subspace of orthogonal to the original 1 in a way that preserves the superpositions so a superposition in our original subspace gets mapped to a superposition with the same amplitudes in our new subspace we can undo this by applying a unitary transformation Of course in order to do that we need to figure out which error happened and we do that by measuring an observable we measured observable the so-called error syndromes which tell us which error occurred and that tells us which unitary correction we need to apply that will will generalize this a little bit in the course of the talk and there's a lot more that I won't have time to get to but this is the basic structure that we start from not all the codes that I've written down so far are examples of what are called stabilizing this was something recognized after the fact by Daniel Gottesman who who basically created this theory so let's see what we mean by a stabilizer so 1st of all when we measured the parities in the bit flip code we were actually measuring 2 ables hard tensor product of Z on the 1st 2 cubits but for the for the 1st parity and on the 2nd to Cuba's for the 2nd parity that the tensor products of pally operators so like poly operators they have eigen values of plus 1 and minus 1 in are encoded state which is a superposition of these 2 code words that is a plus one eigenstate of both of these observables it in fact that's how we will now define code space the code space is the simultaneous plus 1 eigenstate of these two observables so we call these observables the stabilizer generators the the generators because so we can use these 2 operators to generate a group and any operator in that group I will have states of this form it's plus 1 Eigen's but then the air operators that this code corrects again there were x applied you the 1st 2nd or 3rd keep it and also the identity so these X operators NT commute with 1 or the other or both of these two observables and that's how we detect the error when X error occurs as we move into an orthogonal subspace where 1 or both of these operators has eigen value minus 1 so by measuring these operators if we get plus 1 for both of them or we conclude no error has occurred and if we get minus 1 for 1 or both of them we can deduce an error has occurred and which area it was so similarly the phase code has
exactly the same structure but when X is instead of disease so now we're measuring the parity in the X basis instead of Z bases and finally the Shor code has 8 stabilizer generators so as to detect the bit-flip and phase-flip of errors in that code we use we measure these observables so from here on out I'm going to commit the tensor product symbol which takes up room doesn't add anything to our understanding so this is the general notation used in this field in all 3 of these codes the codes space is the simultaneous plus 1 eigen space of a set of commuting stabilizer generators that's important all of these operators commute with each other which means that we can measure them all simultaneously or in any order without causing disturbance to the values of the other operators but if they were on Thai commuting that in general measuring 1 would disturb the value of the other will later see a generalization of this scheme that actually allows this so-called opera a quantum error correcting codes but the basic scheme of these have to be commuting generators which means that the group they generate is an abelian group so here's a kind of mathematical picture we're going to use for simplicity I am going to make use of the discretization errors and assume I set of correctable errors are themselves how operate so OK but now the poly operators form a basis so any error operator can be written in terms of how operators follow we might lose something by making this change so Frances it might be more efficient you might need to include a larger number of poly operators in your correctable errors set in order to describe all of your physical areas but it simplifies the mathematical notation so for now I'm going to assume that and once we assume that all of our operators are stabilizer generate and here operators of poly operators we can make use of a very useful mapping between the poly operators and streams of bits now the important thing is for these areas we don't actually care about their overall phase when errors applied its overall phase is a global phase and therefore is physically relevant so all we really care about is the commuting structure of this set of operators and if that's all we care about then we can write every operator the that in terms of whether it's a z operator and hex operator or why operator which includes both the Z and on neither which would just be the identity so for up a how operator on 3 cubits we could use a string of 6 bits for each location we indicate whether they opting on that location how include is a factor of Z for a factor of acts or both or neither so this string here 0 1 1 1 1 0 corresponds to the operator X Y Z the first one has 0 season 1 the 2nd 1 has 1 Z and 1 x which is a y and the 3rd 1 has 1 C and no axes which is so there's a mapping between Paoli operators on and cubits and strings of 2 N bits this strings of 2 and that's
have a structure where the bits come in pairs and this is what's called a symplectic structure so symplectic space is a space where the degrees of freedom come in pairs but we can define a special kind of inner product it's not true inner product but is what we'll call a symplectic product between the strings of bits so we have a string of 2 and that's with his pardon in ex part and another 1 and so there's a z and access the strings and the 2nd 1 is the primed X primed the product we get is by taking the inner product of Z with X prime and X with the prime and then adding them where this is all binary arithmetic OK so what we end up with is a single bit when we take this symplectic product OK the if we have 2 poly operators whose corresponding strings are U and V it turns out that this symplectic product between their bit strings determines whether these operators are commuting her head he was really doing is capturing whether we have z ies overlapping with x isn't even or an odd number of tall so if n you in in the commute then the symplectic product of their two bit strings will be 0 if they had to commute the symplectic product will be 1 so that means that we can describe a quantum error correcting code that encodes KQ bits into physical qubits using a matrix with N minus K rows and 2 n columns so the 2 in columns represent the bit strings that represent each of of the stabilizer generators and the rows there's 1 row stabilizer generous so to give an example here here's a matrix this is this is the half of the matrix and this is the X half the matrix each row corresponds to 1 stabilized and we look at the 1st row we see we have a 1 in this the place in a 0 here so that would be is the operator on the 1st Cuban a 1 and a 0 gives a 0 and so forth so that gives us the 1st stabilizer generated each of the subsequent rows gives us 3 remaining operators and we can check if these operators will commute with each other by taking the symplectic product between the rows self the symplectic product between the rows is 0 then the set of operators the result all communities the handy thing about this it seems a little fiddly an abstract 1 out his work with the operator the we manipulate matrices like this using plain old ordinary linear algebra over binary variables that can be very handy follow if we think of this matrix as being itself of a parity check matrix for a classical code we realize that there is a map between Our classical linear codes of this structure and quantum stabilizer
so a stabilizer codes the code space is the simultaneous plus 1 eigen space of a set of stabilizer operators which are also pally operators but the correctable errors set it has to be given to you in for it to be correctable 1 of these 2 conditions has to hold so the 1st condition here is the 1 that I said before in group-theoretic notation if we consider 2 different errors in the set they map us to 2 orthogonal subspaces in such a way that if we 1st apply in 1 and in the correction for a 2nd error we should not get back to the code space so that implies that these 2 errors have distinct syndromes we can tell them apart and know which which error correction to apply however there is an exception to this if we have 2 errors that behave exactly the same that is they mapped the state to the same error space such that the same correction would correct both of those errors then that's OK even though we can't tell those errors apart we can still correct so this is the phenomenon of too generous which is a purely quantum phenomenon classical codes do not exhibit this you can cook up classical versions of this but they're rather contrived OK so Here's an example we describe it error by a symplectic string that we see we have a 1 on the 4th bit on the easy side and the X. side so this string represents a wide error on the 4th Cuban if we take our Centrex from the previous slide that represents the stabilizing generators and take It's symplectic product with this error we get a vector containing a series of zeros and ones this is the signature the syndrome associated with this error in other words this is saying that the 1st stabilizer generator commutes with this error but the 2nd 3rd and 4th stabilizing generators and he can be with this and so when we measure those stabilizer generators will get a plus 1 for the 1st and a minus 1 for each of the others and that's the finger print the tells us which error has occurred once we know that will say off this was a wire on Cuban a before and we can apply a why gate to undo it so we can figure out the properties of the correctable errors set on the code working in terms of these interests this symplectic structure is a classical code we can think of this is being a parity check matrix where were defining the parity check it using this funny symplectic product instead of the usual your product but it's not the kind that 1 normally encounters however we can build symplectic codes like that out of more standard kinds of classical linear codes and where the 1st examples of this was was called this now called the CSS construction after Calderbank Shorenstein CIDA here is you take the binary code or to binary codes any construct a symplectic matrix that looks like this now this H 1 is entirely on the seaside is only zeros on the exercise 2 is entirely on the X. side with only zeros on the seaside so this will give us a set of stabilizer generators containing only the identity and Z and this will give us a set of stabilizer generators containing only the identity and in order for this to be a commuting set we require that H 1 times age to transfer this is not a standard binary of matrix multiplication this has to be the 0 matrix OK if that's true then there's a set of pally operators to correspond to the rows of this matrix which give us a valid quantum error correcting code from if this H 1 is the same as H 2 this condition is the same as saying that the rows of H are themselves codewords that is the parity checks of this code part of themselves contained in the code so code that has the property is called dual containing Hi if we use 2 different codes then what we're saying is that the parity checks of H 1 are contained in the code described by each 2 and vise versa so if these 2 codes go classical linear codes have the parameters N K 1 D 1 so that K 1 is the number of bits encoded in D 1 is the minimal distance of the code and the 2nd code is in 1 K 2 D 2 obviously the ends have to be the set then the quantum code we construct in this way users can kill bets it can encode K 1 plus K 2 minus and cubits and the distance will be at least the minimum of these 2 distances the way of thinking of that is we can correct up to you but well D 1 over 2 arises in a war so I X errors and up to D 2 over to z errors so we can whichever of these is the that is the minimum that is the restriction on how many general hairs we can correct the OK in principle they could actually be higher than but it's at least this minimum so
that brings us to the steam curve so this steam code was designed and built from 2 copies of the classical Hamming code so the encoder encodes 4 bits into 7 bits and has a distance of 3 which means it can correct a single bit flip there what's that any scheme did was he took 2 copies of this This is the structure that we now a tribute to it 1 for correcting X errors in 1 of the sort 1 for correcting years in 1 for correcting X errors and he applied them both this set of cooperators commutes with this set of operators so we can measure them all and there's a simultaneous plus 1 eigen space of these which is of dimension to how could we figure that out where the 7 bits and each of these 2 codes encoded for classical bits so using this formula
we would say that there's 4 plus 4 minus 7 or 1 cubic that's encoded so we see the rate is much
lower we can't protect nearly as many cubits with this with the same number size code word as we could classically and that reflects the fact that there are many more kinds of errors the quantum information is subject to it requires more redundancy in a sense to protect against them all so here the basis
vectors of the code space that kind of large and busy and so in fact writing these down takes up more room than right this set of stabilizer generators it is we got a larger a larger code blocks this becomes more and more true the size of the codewords grows exponentially whereas the size of the number of stabilizer generators and their length will grow only linear so 1 of the tremendous advantages of the stabilizer formalism is that it's a much more compact representation for the code and this is similar to classical linear codes words often much easier to represent the code by writing down its parity check matrix then by writing down the list of all possible codewords which may be exponentially long focus just 1 more point we can think of a CSS code like this as being actually the intersection of 2 curve we have 1 code here that protects against Z errors and that code could could could for cubits we have a co year the protects against X errors that could also encode for students but if we want protect against both of them this defined sub subspaces this defined some subspace the intersection of those 2 subspaces is only 2 dimensional so it can encode only to dimensions 1 cubic know there's a natural isometry
between the symplectic pairs of bits Z 2 2 and the court ternary field GF for heart so if we design are they could ternary code in a classical code over quot follow that is dual containing so all of the operators again will be commuting then we can map the check matrix for that recode into a symplectic matrix of this form where each of the rows of this is mapped into 2 bits therefore elements of the finite field of size for it we mapped them to the bit pairs 0 0 0 1 1 0 and 1 1 which would be the identity X Y FIL and was it's actually I did x is what so I got that but naturally I have to write them in that were because it's more confusing and so if you constructed so this construction was proposed in a paper by Calderon Gray Shor Sloan and you can prove of relations between the classical code and the quantum code that you construct if the classical code attains the Singleton bound which is a simple limit on how large the distance can be given the rate of the curve in the quantum code attains the quantum version of the singleton bound which is as you see a little bit worse because you have to protect against more kinds of errors and similarly if the classical code attains the shannon limit which of course they don't generally except in in the limit as the block size becomes very very large but a code that does father could ternary symmetric channel would attain the hashing limit for the that the quantum code would attain the hashing limit which is not the capacity but it is a bound on us so for these more general stabilizer codes how do we measure the Harrison your so we saw an example with the bits of code and in fact we can generalize from that I would were measuring a product of poly operators we can do that we can put a parity where the parity is the on the different the different bits the parity is calculated using a different basis on the different that's so for example to contribute to a 0 or 1 in the standard C basis we can just user-controlled not from the bet we want to include to it and so that in the stadium if we want to measure a parity using the X spaces we can apply had a mod before after to switch from the ax to the the bases apply this controlled not and then switch back and for why it turns out you can do the same thing we using these to single qubit beds gets this essay phase gate of more less a square root of this up and and its way the phase gate and it's of Hermitian conjugate and so this would contribute the the parity of the spirit in the wide basis so if we put that all together if we wanted to measure a
stabilizer generator say Y X Z on 3 qubits we could put together a circuit that looks like that so notice I write this y x but I actually I flipped this bit in the opposite order just to make this a circuit a little more compact the 3rd that we apply a simple simple controlled on the 2nd then we 1st to the from the extra busy basis and then flip back and the 1st that we switch between the Y and this this and then what we measure here will be the the the parity of this operator that is your plus 1 or minus 1 and building of exactly the same components we can measure the eigen value of any poly operator of this type follow no the way I've drawn this year they all go to the same bit which is fine if we assume that all of these operations are themselves error-free in fault-tolerant quantum computation we can't assume that and then you wouldn't wanna use circuit of this form because in a single error here could propagate up 2 or 3 of these so in fault-tolerant quantum computation instead of all being applied to the same that we would create an entangled state of 3 qubits here and measure them all so that an error can propagate to at most 1 other tidbit and I won't say I think anything more about fault-tolerant computation in this talk but Andrew will say a great deal about OK similarly we can define in encoding and decoding circuits for any stabilizer code in a way analogous to what we did for the bits of now here's a way of thinking about it if you're encoding take you bits into N cubits you start with the state of your K cubits plus and minus K and select cubits in a standard state usually 0 we then are just implying a unitary transformation to go to the encoded state we wanna find the circuit that does this unit here you he the thing to notice is that this initial state is also innocence as stabilizer code this state has stabilizes which adjusts the C operators on each of the insula cubits so z applied to Cu K plus 1 K plus 2 and 1 so all of these simultaneously having eigen value plus 1 is the same as saying is on so those are all in the state 0 since this is the stabilizer code and this is a stabilizing we can think of this unitary encoding operation as mapping each of these z operators to 1 of the stabilizer generators of arc follow and were mapping poly operators to poly operators we can find a circuit for you which is what's called a Clifford circuit includes only controlled not had a margin phase gates since these 3 gates
map poly operators to each other in a in a very well known way weekend take a step-by-step operation to transform our initial stabilizer generators z these z operators to our final stable so if you look at that for say the phase-flip code here we started with is the operator on cubits 2 and 3 so we just have information Cubitt into answer lives we apply our see knots because of the way see knots where that's the same as doing column operations between the columns of this matrix so this 2nd column gets added to the 1st hello and the 3rd the also deaths were so we end up with a symplectic matrix of this form and then when we apply had mods all these operators become X operate say you can plot your encoding circuit by figuring out the series of column operations you need to do to transform your starting matrix into the matrix for your final code is encoding unitary is are
not uniquely defined the 1st there's lots of different sets of generators for the same stabilizing group 2nd we don't really care in this what that unitary does to the answer lies if they don't start in the state 0 but by making appropriate choice of the encoding unitarity you can choose the decoding unitary to simply be the inverse operation that is just the hermitian conjugate the encoding circuit and you can choose that in such a way that few humanity encoding applying some error in decoding those absolute cubits at the end of this will actually hold values that tell you which error syndrome occurred which would be enough for you to figure out what you have to do to correct the error on the remaining information here so this is a good way of understanding how error correcting codes allow you to correct errors these ads store extra information in them about which error has occurred so having more hassle as potentially allows you to correct more errors because you can keep more information about the errors that have occurred so I'm almost out of time so I'm going to have to go rather quickly I'm afraid found when we apply our encoding circuit we can look at the poly operators that act on information qubits this coming anticommuting pairs X and Z because they're pally operators they'll be transformed by the encoding circuit into some new operate so you can think of this like Heisenberg picture we by tracking how these operators transform we can keep track of what of his storing part her quantum information so in the bit flip code the X. how operator becomes redundantly spread across 3 key but this Z does not which is why this can protect against a bit flips but not against phase flips with a phase flip code the opposite happens we have multiple these in only a single act and then with the steam we can protect against both X and Z but logical operators are not actually uniquely defined because they're equivalent to other operators that include being mulled these operators multiplied by heating element of the stable so logical operators are not a group but they're instead an equivalence class of operators just a a couple of
words about the generous I mentioned before that it's possible for crude diffs distinct areas to have the same syndrome and the same correction in a quantum so this is what too generous but for example in the Shor code the qubits are divided into triplets and as the error on any given in the triplet has the same syndrome in the same correction the idea of De generously is actually not a property of the code but rather of the code together with the correctable errors set so for any code you can find some correctable errors set where that code will be too generous so generally when we say code is to generate not degenerate were we're speaking with respect to some standard set of errors like localized areas of but did you ever see itself is as much a function of our choice of correctable errors as is of the code and in fact you can have extreme version of this if you have a generous if you have an error that's actually equal to any errors of to an element of the stabilizer we don't correction at all being multiplied by an element of the stabilizer will not change the code that means in the extreme case where all of our correctable errors are elements of the stabilizer we don't have to do anything at all and that's in what's called a decoherence free subspace it generally only arises in practice when they're special symmetries to our system and I have
almost no time to say anything about how operators can but I'll just say this much if in addition to and so as they can store information about the errors that occur we can also have some extra systems that we don't keep track of so we can use them to keep track of shares but on the other hand we don't really care whether or not Hairer is occur to them so a code with this structure we call an operator quantum correcting and because of the presence of this subsystem and operator code is not a subspace more so for the standard codes the codewords all formed a subspace that would only be true here if we could guarantee that the different components had the same state roof G and however this gives us some freedom to play around with what kinds of operations we do for our code
well I'll skip this so here is the
most famous example of this so-called baking sure could we take the 9 q bits of the Shor coding we arrange them is a little 3 by 3 grid like this in here stabilizer operator they may look at these without too much difficulty you'll realize that these guys do not all commute with each other so for instance this stabilizer generator does not commute with this 1 that's why I put 2 terms stabilizer in quotes follow but it turns out that the non commuting follow parts of these stabilizer generators are based on non commuting operators that act on this
gage subsystem so even though
measuring 1 of these operators might disturb the state of a different 1 then the effect of that disturbance applies only to the gage system and and to be neglected now we've actually lost some power by not using the GATE system to to give us information about which error has occurred but you see we've greatly simplified the kinds of operate operations we have to do because all of these stabilizers now are just to go to bed operators they're much easier to measure and that can lead to a much higher error threshold and fault tolerance on competition so I lied I did say 1 more thing about fault tolerant com on come so I'm sorry I didn't have more time to go into this just to sum up
quantum error correction is indeed possible despite the doubts of the year the skeptics the principles are actually very similar classical error correction based on the use of error correcting codes in order make these work for quantum systems we have to make use of several inches important tricks discretization of errors in the ability to marry me to measure errors in Jones without measuring the the states of the individual qubits almost all of the quantum error correcting codes in this study the stabilizer codes almost and there's a deep connection between these codes and classical linear codes though not all classical linear the for stabilizer codes because all your operators of poly operators you can use just Clifford's circuits containing only control knots had a margin phase in in order to do your encoding decoding and stabilizer measurements quantum codes also exhibit this phenomenon called a generous each can be exploited for more effective of in simpler circuits and finally operator course subsystem codes go beyond via the structure that I talked about for most of this introduction and they they give up some of the error correcting power of a standard code in exchange for both the ability to do a certain amount of passive error correction and the ability to simplify our operations so thank you very much welcomed to Q C 11 the so I think we have time for questions they all know it all I really was a very nice I did have 1 curious for in a way it possible the task of human on so it's question fight it could it could use a simple example I never considered those a simple example of 1 class called them out so you can define something that's like DeGeneres for a classical code if instead of your code word to being unique bit strings you find your code word to be saying equivalence class of bit strings so for example if you have a string of and bits and your errors only flipped to bits at a time then you can consider say all even strings to be 1 equivalence class in all hard strings to be 1 equivalence class can this two bit flips will always leave you with in that class so there's passive error correction it's like I said it's a bit contrived but but you can you can generalize from that example thank you again thank you the same Sonic speakers and you all the last little about
Viterbi-Algorithmus
Fehlererkennungscode
Decodierung
Diskretes System
Stichprobenfehler
Quantisierung <Physik>
Vorwärtsfehlerkorrektur
Kombinatorische Gruppentheorie
Quantisierung <Physik>
Data Mining
Bit
Punkt
Prozess <Physik>
Extrempunkt
Gesetz <Physik>
Hamilton-Operator
Internetworking
Fehlertoleranz
Vorwärtsfehlerkorrektur
Chi-Quadrat-Verteilung
Analogieschluss
Nichtlinearer Operator
Kategorie <Mathematik>
Krümmung
Klassische Physik
Quantencomputer
Trägheitsmoment
Datenfeld
Einheit <Mathematik>
Verschlingung
Gerade Zahl
Decodierung
Information
Fehlermeldung
Aggregatzustand
Instantiierung
Stabilitätstheorie <Logik>
Maschinencode
Subtraktion
Multiplikation
Kreisring
Klasse <Mathematik>
Nichtlineares Zuordnungsproblem
Interaktives Fernsehen
Quantenmechanik
Stichprobenfehler
Informationsmodellierung
Reelle Zahl
Quantenkommunikation
Zeitrichtung
Quantisierung <Physik>
Datenstruktur
Hilfesystem
Einfach zusammenhängender Raum
Soundverarbeitung
Fehlererkennungscode
Protokoll <Datenverarbeitungssystem>
Schlussregel
Physikalisches System
Binder <Informatik>
Mapping <Computergraphik>
Linearer Code
Flächeninhalt
Digitaltechnik
Wärmeausdehnung
Lie-Gruppe
Parametersystem
Maschinencode
Bit
Fehlererkennungscode
Konvexe Hülle
Kategorie <Mathematik>
Klasse <Mathematik>
Klassische Physik
Codierungstheorie
Geräusch
Gebäude <Mathematik>
E-Mail
Stichprobenfehler
Multiplikation
Flächeninhalt
Einheit <Mathematik>
Wort <Informatik>
Information
Vorwärtsfehlerkorrektur
Zeichenkette
Fehlermeldung
Bit
Punkt
Momentenproblem
Drehung
Computerunterstütztes Verfahren
Extrempunkt
Superposition <Mathematik>
Raum-Zeit
Eins
Quantenschaltung
Existenzsatz
Zustand
Vorwärtsfehlerkorrektur
Analytische Fortsetzung
Einflussgröße
Analogieschluss
Funktion <Mathematik>
Nichtlinearer Operator
Addition
Kategorie <Mathematik>
Reihe
Klassische Physik
Quantencomputer
Analogrechner
Unterraum
Verknüpfungsglied
Menge
Einheit <Mathematik>
Datenverarbeitungssystem
Gerade Zahl
Elektronischer Fingerabdruck
Information
Decodierung
Ordnung <Mathematik>
Fehlermeldung
Aggregatzustand
Maschinencode
Subtraktion
Wasserdampftafel
Unitärer Operator
Zahlenbereich
Dialekt
Äquivalenzklasse
Quantenmechanik
Stichprobenfehler
Physikalische Theorie
Datentyp
Inverser Limes
Quantisierung <Physik>
Zusammenhängender Graph
Datenstruktur
Leistung <Physik>
Qubit
Diskrete Wahrscheinlichkeitsverteilung
Fehlererkennungscode
Knoten <Mathematik>
Konvexe Hülle
Kontinuumshypothese
Einfache Genauigkeit
Mailing-Liste
Physikalisches System
Objekt <Kategorie>
Hilbert-Raum
Verschränkter Zustand
Digitaltechnik
Basisvektor
Gamecontroller
Wort <Informatik>
Hill-Differentialgleichung
Klon <Mathematik>
Qubit
Nichtlinearer Operator
Maschinencode
Dicke
Bit
Kontinuumshypothese
Warteschlange
Information
Drehung
Superposition <Mathematik>
Einflussgröße
Aggregatzustand
Qubit
Nichtlinearer Operator
Kraftfahrzeugmechatroniker
Bit
Maschinencode
Krümmung
Schaltnetz
Einfache Genauigkeit
Physikalisches System
Stichprobenfehler
Freiheitsgrad
Menge
Einheit <Mathematik>
Vorzeichen <Mathematik>
Basisvektor
Nichtunterscheidbarkeit
Zusammenhängender Graph
Information
Instantiierung
Fehlermeldung
Aggregatzustand
Qubit
Nichtlinearer Operator
Bit
Maschinencode
Total <Mathematik>
Konvexe Hülle
Extrempunkt
Polygon
Superposition <Mathematik>
Stichprobenfehler
Bildschirmmaske
Einheit <Mathematik>
In-Memory-Datenbank
Nichtunterscheidbarkeit
Digitaltechnik
Basisvektor
Gamecontroller
Hill-Differentialgleichung
Datenstruktur
Phasenumwandlung
Gammafunktion
Normalvektor
Aggregatzustand
Fehlermeldung
Bit
Gruppenkeim
Benutzeroberfläche
Superposition <Mathematik>
Raum-Zeit
Streaming <Kommunikationstechnik>
Zahlensystem
Eigenwert
Nichtunterscheidbarkeit
Stützpunkt <Mathematik>
Vorwärtsfehlerkorrektur
Phasenumwandlung
Nichtlinearer Operator
Multifunktion
Abelsche Gruppe
Nummerung
Kommutator <Quantentheorie>
Teilbarkeit
Unterraum
Tensorprodukt
Generator <Informatik>
Datenfeld
Menge
Gerade Zahl
URL
Ordnung <Mathematik>
Aggregatzustand
Fehlermeldung
Zeichenkette
MUD
Eigenwertproblem
Stabilitätstheorie <Logik>
Maschinencode
Relationentheorie
Mathematisierung
Unitärer Operator
Zahlenbereich
Diskrete Gruppe
Polygon
Term
Stichprobenfehler
Physikalische Theorie
Bildschirmmaske
Quantisierung <Physik>
Luenberger-Beobachter
Datenstruktur
Gammafunktion
NP-hartes Problem
Transinformation
Mathematik
Sechsecknetz
Orthogonale Funktionen
Symboltabelle
Mapping <Computergraphik>
Flächeninhalt
Basisvektor
Wort <Informatik>
Polynomialzeitalgorithmus
Resultante
Matrizenrechnung
Bit
Extrempunkt
Versionsverwaltung
Binärcode
Raum-Zeit
Eins
Zahlensystem
Eigenwert
Nichtunterscheidbarkeit
Vorwärtsfehlerkorrektur
Nichtlinearer Operator
Konstruktor <Informatik>
Parametersystem
Multifunktion
Kategorie <Mathematik>
Reihe
Klassische Physik
Ausnahmebehandlung
Symplektischer Raum
Biprodukt
Elektronische Unterschrift
Kommutator <Quantentheorie>
Skalarproduktraum
Rechenschieber
Generator <Informatik>
Verknüpfungsglied
Menge
Einheit <Mathematik>
Gerade Zahl
Konditionszahl
Hochvakuum
Ordnung <Mathematik>
Aggregatzustand
Zeichenkette
Fehlermeldung
Standardabweichung
Stabilitätstheorie <Logik>
Maschinencode
Physikalismus
Zahlenbereich
Term
Stichprobenfehler
Freiheitsgrad
Datensatz
Variable
Multiplikation
Elektronischer Fingerabdruck
Quantisierung <Physik>
Lineare Geometrie
Abstand
Datenstruktur
Schreib-Lese-Kopf
Qubit
Fehlererkennungscode
Matrizenring
Konvexe Hülle
Validität
Vektorraum
Primideal
Mapping <Computergraphik>
Linearer Code
Mereologie
Wort <Informatik>
Nichtlinearer Operator
Bit
Maschinencode
Hausdorff-Dimension
Thumbnail
Klassische Physik
Nummerung
Bitrate
Kommutator <Quantentheorie>
Stichprobenfehler
Raum-Zeit
Quick-Sort
Ausdruck <Logik>
Menge
Einheit <Mathematik>
Eigenwert
Abstand
Decodierung
Datenstruktur
Vorwärtsfehlerkorrektur
Kurvenanpassung
Matrizenrechnung
Stabilitätstheorie <Logik>
Maschinencode
Punkt
Relationentheorie
Hausdorff-Dimension
Selbstrepräsentation
Formale Grammatik
Zahlenbereich
Extrempunkt
Raum-Zeit
Stichprobenfehler
Quantisierung <Physik>
Isometrie <Mathematik>
Kurvenanpassung
Dicke
Klassische Physik
Mailing-Liste
Vektorraum
p-Block
Fokalpunkt
Unterraum
Generator <Informatik>
Menge
Linearer Code
Einheit <Mathematik>
Rechter Winkel
Gerade Zahl
Basisvektor
Wort <Informatik>
Information
Randverteilung
Matrizenrechnung
Bit
Versionsverwaltung
Computerunterstütztes Verfahren
Element <Mathematik>
Extrempunkt
Bildschirmfenster
Raum-Zeit
Kreisbogen
Fehlertoleranz
Einheit <Mathematik>
Eigenwert
Trennschärfe <Statistik>
Unitäre Gruppe
Nichtunterscheidbarkeit
Stützpunkt <Mathematik>
Wurzel <Mathematik>
Vorwärtsfehlerkorrektur
Kurvenanpassung
Phasenumwandlung
Konstruktor <Informatik>
Nichtlinearer Operator
Ternärkörper
Gebäude <Mathematik>
Klassische Physik
Quantencomputer
p-Block
Bitrate
Biprodukt
Generator <Informatik>
Verknüpfungsglied
Einheit <Mathematik>
Transcodierung
Gerade Zahl
Decodierung
Ordnung <Mathematik>
Fehlermeldung
Standardabweichung
Aggregatzustand
Maschinencode
Stabilitätstheorie <Logik>
Unitärer Operator
Dialekt
Polygon
Stichprobenfehler
Bildschirmmaske
Datensatz
Datentyp
Inverser Limes
Galois-Feld
Quantisierung <Physik>
Zusammenhängender Graph
Abstand
Gammafunktion
Qubit
Relativitätstheorie
Einfache Genauigkeit
Kanalkapazität
Mapping <Computergraphik>
Verschränkter Zustand
Basisvektor
Digitaltechnik
Innerer Automorphismus
Lokales Netz
Matrizenrechnung
Bit
Subtraktion
Maschinencode
Stabilitätstheorie <Logik>
Klasse <Mathematik>
Gruppenkeim
Element <Mathematik>
Case-Modding
Äquivalenzklasse
Mathematische Logik
Polygon
Stichprobenfehler
Weg <Topologie>
Bildschirmmaske
Quantisierung <Physik>
MIDI <Musikelektronik>
Vorwärtsfehlerkorrektur
Phasenumwandlung
Auswahlaxiom
Gammafunktion
Qubit
Nichtlinearer Operator
Transinformation
Knoten <Mathematik>
Reihe
Mathematisierung
Automatische Differentiation
Kommutator <Quantentheorie>
Mapping <Computergraphik>
Generator <Informatik>
Umkehrfunktion
Menge
Einheit <Mathematik>
Mereologie
Digitaltechnik
Information
Innerer Automorphismus
Fehlermeldung
Aggregatzustand
Maschinencode
Subtraktion
Stabilitätstheorie <Logik>
Freeware
Gemeinsamer Speicher
Versionsverwaltung
Sprachsynthese
Element <Mathematik>
Information
Stichprobenfehler
Physikalisches System
Weg <Topologie>
Symmetrie
Ausdruck <Logik>
Quantisierung <Physik>
Zusammenhängender Graph
Vorwärtsfehlerkorrektur
Datenstruktur
Auswahlaxiom
Qubit
Nichtlinearer Operator
Addition
Lineares Funktional
Kategorie <Mathematik>
Befehlscode
Eichtheorie
Physikalisches System
Quantisierung <Physik>
Unterraum
Flächeninhalt
Menge
Einheit <Mathematik>
Wort <Informatik>
Information
Aggregatzustand
Standardabweichung
Fehlermeldung
Nichtlinearer Operator
Stabilitätstheorie <Logik>
Bit
Maschinencode
Konvexe Hülle
Eichtheorie
Kommutator <Quantentheorie>
Term
Quantisierung <Physik>
Physikalisches System
Generator <Informatik>
Mereologie
Instantiierung
Randverteilung
Stabilitätstheorie <Logik>
Bit
Maschinencode
Messfehler
Klasse <Mathematik>
Diskrete Gruppe
Äquivalenzklasse
Entartung <Mathematik>
Polygon
Stichprobenfehler
Fehlertoleranz
Quantisierung <Physik>
COM
Vorwärtsfehlerkorrektur
Datenstruktur
Phasenumwandlung
Einflussgröße
Leistung <Physik>
Qubit
Beobachtungsstudie
Einfach zusammenhängender Raum
Soundverarbeitung
Nichtlinearer Operator
Schwellwertverfahren
Fehlererkennungscode
Knoten <Mathematik>
Eindeutigkeit
Klassische Physik
Mathematisierung
Ähnlichkeitsgeometrie
Physikalisches System
Verknüpfungsglied
Linearer Code
Digitaltechnik
Ablöseblase
Wort <Informatik>
Decodierung
Information
Ordnung <Mathematik>
Aggregatzustand
Fehlermeldung
Zeichenkette
Standardabweichung

Metadaten

Formale Metadaten

Titel Quantum Error Correction and Quantum Error-Correcting Codes
Serientitel Second International Conference on Quantum Error Correction (QEC11)
Autor Brun, Todd
Lizenz CC-Namensnennung - keine kommerzielle Nutzung - keine Bearbeitung 3.0 Deutschland:
Sie dürfen das Werk bzw. den Inhalt in unveränderter Form zu jedem legalen und nicht-kommerziellen 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/35322
Herausgeber University of Southern California (USC)
Erscheinungsjahr 2011
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik, Mathematik, Physik
Abstract This tutorial briefly introduces the important principles of quantum error correction and quantum error-correcting codes. We look at classical error correction, and the important limitations in working with quantum information. The basic structure of a quantum code is laid out, and how errors are detected and corrected. We introduce stabilizer codes and their connection to classical linear codes, and show how quantum codes can be constructed from classical codes. The problem of encoding and decoding is briefly discussed. Finally we touch on degeneracy and passive error correction in quantum codes.

Zugehöriges Material

Ähnliche Filme

Loading...
Feedback