3D local qupit quantum code without string logical operator
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 48 | |
| Autor | ||
| Mitwirkende | ||
| 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. | |
| Identifikatoren | 10.5446/35196 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache |
Inhaltliche Metadaten
| Fachgebiet | ||
| Genre | ||
| Abstract |
|
12
23
24
29
31
37
38
00:00
Quantisierung <Physik>CodeZeichenketteStellenringNichtlinearer OperatorCodeKategorie <Mathematik>Vorlesung/Konferenz
00:30
ZeichenketteE-MailCodePartikelsystemQuantisierung <Physik>StellenringFehlermeldungEnergiedichteCodeNatürliche ZahlZeichenketteCodierungFinitismusGittereichtheorieLogarithmusPunktrechnungQuantisierung <Physik>StellenringLinearisierungFehlermeldungEnergiedichteGraphfärbungFlächentheoriePartikelsystemMathematische LogikSoftwaretestMereologiePhysikalisches SystemPunktgitterFeuchteleitungWort <Informatik>EinfügungsdämpfungEndliche ModelltheorieMultiplikationsoperatorVorwärtsfehlerkorrekturDesign by ContractComputeranimation
02:20
EnergiedichteFeuchteleitungKategorie <Mathematik>Physikalischer EffektKonstanteAbstandExistenzsatzEndliche ModelltheorieCodierungComputeranimation
02:52
CodeBinärdatenPrimidealQuantisierung <Physik>BeobachtungsstudieCodePrimzahlWürfelGenerator <Informatik>DimensionsanalyseBinärcodeDifferenzenrechnungQuantisierung <Physik>StellenringÄhnlichkeitsgeometrieTranslation <Mathematik>PunktgitterStabilitätstheorie <Logik>Web SiteDifferentePartikelsystemQubitInvarianteBitFormale GrammatikStichprobenumfangVertauschungsrelationSystemaufrufComputeranimation
04:14
Produkt <Mathematik>VerschiebungsoperatorPhasenumwandlungNichtlinearer OperatorTranslation <Mathematik>FrequenzKonditionszahlRandwertRichtungRelativitätstheorieSchaltnetzHamilton-OperatorFrequenzVerschiebungsoperatorPhasenumwandlungBetafunktionLeistung <Physik>MereologieMultiplikationPolygonRechenschieberSimplexverfahrenExogene VariableNichtlinearer OperatorUnitäre GruppeTranslation <Mathematik>RichtungStabilitätstheorie <Logik>Kanonische VertauschungsrelationJensen-MaßEndliche ModelltheorieRandwertEinsCodeWürfelQuantisierung <Physik>RestklasseVertauschungsrelationWurzel <Mathematik>MultifunktionSymplektischer RaumComputeranimation
06:17
Translation <Mathematik>RichtungFrequenzKonditionszahlRandwertKommutativgesetzMathematische LogikZeichenketteNichtlinearer OperatorKonstanteNebenbedingungSymmetrische MatrixFarbverwaltungssystemUmkehrung <Mathematik>CodeÄquivalenzklasseRelation <Informatik>Transformation <Mathematik>SymmetriePunktgitterCodeNebenbedingungStabilitätstheorie <Logik>Endliche ModelltheorieComputerspielFormale SpracheMathematische LogikRelativitätstheorieSymmetrieTransformation <Mathematik>ZeichenketteFrequenzMAPGenerator <Informatik>Kategorie <Mathematik>ÄquivalenzklasseBetafunktionGalois-FeldGlättungGruppenoperationMereologiePermutationPrimzahlzwillingeRechenschieberStellenringUmkehrfunktionZahlenbereichLogische ProgrammierungSystemaufrufClifford-AlgebraKonstanteExogene VariableNichtlinearer OperatorParametersystemCASE <Informatik>GammafunktionPunktgitterOffene MengeWort <Informatik>HilfesystemRichtungMultifunktionSymplektischer RaumFlächentheorieKanonische VertauschungsrelationVorzeichen <Mathematik>Jensen-MaßEreignishorizontKonditionszahlDickeMultiplikationsoperatorRandwertRechter WinkelCodierungProdukt <Mathematik>Quantisierung <Physik>RestklasseVertauschungsrelationSpezielle lineare GruppeComputeranimation
11:31
SymmetriePunktgitterÄquivalenzklasseRelation <Informatik>Transformation <Mathematik>Clifford-AlgebraSymmetrische MatrixMathematische LogikSymmetrieZeichenketteZeichenvorratKategorie <Mathematik>FinitismusBetafunktionBitStellenringSystemaufrufNichtlinearer OperatorParametersystemGammafunktionPunktgitterSchnittmengeDatentransferMultifunktionJensen-MaßKonditionszahlElement <Gruppentheorie>sinc-FunktionRandwertSpezielle lineare GruppeCodeTransformation <Mathematik>Computeranimation
12:41
KonditionszahlMathematische LogikZeichenketteCliquenweiteCodeFehlermeldungMethode der logarithmischen BarriereCodeMathematische LogikZeichenketteCodierungFinitismusLogarithmusQuantisierung <Physik>RechenschieberResultanteTheoremZahlenbereichNichtlineares GleichungssystemNichtlinearer OperatorParametersystemFehlermeldungLuenberger-BeobachterStabilitätstheorie <Logik>KonditionszahlCliquenweiteInformationsmanagerPhysikalische TheorieSystemaufrufSchnittmengeWort <Informatik>GraphfärbungVierzigPolstelleComputeranimation
14:28
Exogene VariableCodeCodierung <Programmierung>MultiplikationNichtlinearer OperatorFlächentheorieRelation <Informatik>Offene MengeFeuchteleitungNumerisches VerfahrenCodeLineare AlgebraMathematikMathematische LogikZeichenketteCodierungMatrizenrechnungGenerator <Informatik>Kategorie <Mathematik>DimensionsanalyseFinitismusNebenbedingungBeweistheorieBitGeradeLogarithmusPhysikalisches SystemStellenringTensorTheoremFamilie <Mathematik>ÄhnlichkeitsgeometrieExogene VariableNichtlinearer OperatorParametersystemNormalvektorFehlermeldungEnergiedichtePunktPunktgitterRankingDimension 3RichtungMultifunktionFlächentheorieKanonische VertauschungsrelationVorzeichen <Mathematik>RFIDJensen-MaßKnotenmengeDifferentePartikelsystemDickeMultiplikationsoperatorZweiQubitSchaltnetzTensorproduktTopologieKette <Mathematik>MereologiePhysikalismusPolygonSystemaufrufPunktspektrumInstantiierungCodierung <Programmierung>Wort <Informatik>Endliche ModelltheorieRöhrenflächep-BlockObjekt <Kategorie>Dienst <Informatik>IdentitätsverwaltungComputeranimation
Transkript: Englisch(automatisch erzeugt)
00:22
My name is Isaac Kim from Caltech, and today I'm going to talk about pretty much the same kind of code with a similar property. OK, so here's a general picture of the energy barriers of many local quantum error correcting codes. As we already probably know that in 2D such as Tori
00:42
code and color codes, we have particle-like excitations. So what we can have is at finite temperature, there will be a non-zero probability that the particles and the anti-particles would be created, and they would just diffuse away without extra energy cost. And if they make a non-contractable loop, and that will cause error.
01:00
But we do know at the same time, there is a four-dimensional system, which is a 40 Tori code, which is a finite energy barrier. And the way you can visualize this is basically the elementary particle excitation. Elementary excitation looks like a closed string-like excitation with a finite string tension. So to cause a logical error, you actually
01:20
need to stretch out the closed string all the way up until you fill out the whole surface. And that's where we get the linear energy barrier. And in 3D, the natural generalization of lattice gauge models such as Tori codes can be basically thought in pretty much the same ways as in 2D.
01:40
But here, instead of having a particle and particle, we have particles and string. But since we do have a particle anyway, they will still cause a logical error. And this has been believed to be a general picture for a very long time until last year. Jeongwon Ha introduced a new kind of code. And as in the previous, in 2011,
02:00
Bravian Ha showed that there is actually logarithmic energy barrier for creating a logical error. So just to have a brief recap of the previous talk, I just want to ask the following question, which is, in Ha's code, where does the logarithmic energy barrier for the logical error comes from? And the answer turns out to be fairly simple,
02:21
which is the existence of constant aspect ratio. So as you can see in this picture on the top, this guy and this guy is pretty happy, whereas this guy is not so happy. And the reason why this guy is not so happy is because compared to the size of the anchor, the distance between two anchors are too far away, which is not allowed by the model.
02:41
And this is one of the defining properties of Ha's model. And we're going to look through models that the more general codes that share the same kind of property. So the real question that I want to ask was obviously, are there similar kind of codes? And to think about this question, we revisit how Ha found those codes, which
03:02
is to basically, he found numerically after exhaustive search over binary stabilizer code with certain plausible assumptions, such as they have to commute, and their translation invariant, and they have two stabilizer generators for each cube, et cetera. And our approach is going to be slightly different, because if you take the same approach, we're going to write the same code anyway.
03:22
And the primary difference is that we're going to search through a qubit stabilizer code, instead of a qubit stabilizer code. And it turns out that the stabilizer formulism carries out pretty much the same way when the d is a prime number. So we will study a qubit quantum code, hence the explanation for the exotic title.
03:41
And here are main differences between the Ha's code and our code that I'm going to present. The first difference is that the local particle dimension in Ha's code is 2, whereas in my code, it's a prime number in general. And in Ha's code, he has two particles per site, whereas in our code, we will have just one per site.
04:01
And it'll be the same kind of lattice, a qubit lattice. But instead of having two generators for Ha's code, which resulted in a CSS code, we'll just have one generator for each cube. So this will not be a CSS code. And basically, there is a generic tool that is applicable in these kind of situations.
04:22
And the first thing that you should notice is that instead of a x operator, we should now consider a generalized shift operator, x, and also a generalized phase operator, z, where omega corresponds to the d-th root of the unity. And they satisfy the following, quote unquote, commutation relation, which is encoded by the.
04:43
And the one thing that you should remember is that the commutation relation of these generalized Pauli operators are completely encapsulated by the so-called symplectic product between the symplectic pairs alpha and beta. And the alpha and beta here is actually a combination of alpha 1 and alpha 2, and beta 1 and beta 2.
05:01
So you can see from this relation that two generalized Pauli operators commute with each other if and only if the symplectic product is equal to 0 modulo d, because then omega 2 to d becomes exactly 1, and also for the multiples of d. So our stabilizer generator will look pretty much the same
05:22
as in Haas code. As you can see, we have a cubic generator, and we have eight symplectic pairs. And as I mentioned in the previous slide, alpha will be a general symplectic pair, which represents the generalized Pauli operators.
05:40
And as in Haas code, we will consider a translation of u in three different directions. And also, we will assume a periodic boundary condition. And you can see from the previous slide that u is a general unitary operator. And when d is equal to 2, the nice thing about the Pauli operators are they're not only unitary,
06:02
but they're also Hermitian. But we don't have the luxury anymore in general d. So to actually write down the quantum antibody Hamiltonian, you actually have to hermitize unitary operator. And hence, the Hamiltonian becomes like the following, which is summed over all cubes. And if you think about it, this generic model
06:22
will not result in any kind of meaningful code unless we supply some kind of constraints on it. For one thing, since we are studying a stabilizer code, all the stabilizer generators have to commute with each other. So that's the first condition that we are going to impose on the code.
06:42
And the second condition is pretty much the defining property of Haas code, which is the absence of string logic operator. And basically, there are many ways to interpret it. But the way I understood Haas paper in two steps, there are really two steps in showing the absence
07:00
of string logic operator. The first step is the so-called deformability condition. And in Haas language, it was an eraser. And the basic idea is that if we have a sharp boundary on the logic operator, we can somehow smoothen it out into a more smoothened surface. And the next one is the constant aspect ratio,
07:20
which is that if we have a finite segment of the logical string operator, it cannot get too long. So once we take it for granted for these two facts about the code, then the basic logic behind how you show that there is no string logic operator is something like this. So let's suppose we have a string logic operator. Then we take a look into a particular segment of that.
07:40
And if it is too long, because of the second condition here, we conclude that it becomes just a trivial part. And then we are ending up with a string with a open. Then we will end up with an open string. And then we can apply the first condition, which is a dilutive condition. And the open end of the string will be very sharp. So we will just deform it away
08:01
until we arrive at the trivial operator. So the amazing thing about this is that, first of all, alpha bar is a minus alpha, modulo d in general. Turns out that the commutation relation and the deformability condition, which was the first two conditions that I introduced
08:21
in the previous slide, constrains the stabilizer generator in a very peculiar way. And I have to let you know that the generator here and the generator here corresponds to a different code. So they are a completely different code. And as you can see, they are either
08:41
symmetric or anti-symmetric under the inversion operation. And there's also this extra constraint that the simplistic product between the parameters of the quantum code, which is alpha, beta, and gamma delta, should not be equal to 0, which is a fairly simple constraint that you can check with your hands.
09:02
So from now on, I will denote the code that is represented by this kind of stabilizer generator as a symmetric code and the second one as an anti-symmetric code. And as you can see, it's basically represented by four parameters, which are symplectic pairs. So those are eight numbers altogether.
09:24
And before we get into the detail, I just want to point out there is a very nice equivalence relation, first of which is the lattice symmetry. So if we rotate the lattice, and if we end up with the same quantum code, we should probably count them as the same kind of code.
09:41
And it turns out that under those lattice symmetry, actually, two codes that can be identified if they can be mapped into each other under the permutation of the parameters of the code. And I'll say, if two codes can be mapped into each other under local unitary operation, especially the local Clifford
10:02
transformation, then again, you can identify those two codes as a same one, which is again represented by a special linear group of a 2 by 2 special linear group over a finite field D. And there's one final rather exotic equivalence relation,
10:21
which is the equivalence relation between the symmetric code and the anti-symmetrical. And this is a little bit subtle because if you look at the symmetric code here and the anti-symmetric code here, you can imagine applying a Clifford operation on the second one on the even layer. So in that case, you will map delta bar into delta
10:42
and gamma bar into gamma and beta bar into beta and alpha bar into alpha. And for the stabilized generator behind this guy, we will basically map alpha into alpha bar, beta into beta bar. But since they're basically the same stabilizer generators because they only differ by the sign.
11:04
And all that matters is the commutation relation. So you can see that in the bulk, there is a correspondence between the symmetric code and the anti-symmetric code, but it turns out that in general, if we have a periodic boundary condition, especially the length in the X direction here is odd.
11:21
In that case, we cannot apply that argument anymore. So it turns out that in that case, those two codes are not actually identical. So to summarize a little bit, under the lattice symmetry, we can basically permute the parameters of the code. So from now on,
11:41
instead of writing down all the four elements, I'll just denote it as a set, which is a set of four parameters, alpha, beta, gamma, or delta. And since there's a local Clifford transformation equivalence, I will again identify two, which can be identified each other through a special linear group, element of the special linear group.
12:01
The last one is a really important one because basically when proving the absence of string logical operator, remember there were two conditions, first of which was the formability condition, and the second one was the finite aspect ratio. And through these two conditions, we did not assume anything about the boundary condition, right?
12:21
Which means basically to prove the absence of string, we only need to study the bulk properties of the code. So if you can show that certain symmetry code does not have string logical operator, we can gain it for free that there is a corresponding anti-symmetry code without a string logical operator.
12:41
So this is the main result. So the theorem basically says that the following three conditions on the parameters of the code guarantees an aspect ratio of five for these two codes. But the important thing is that the ratio is finite because that's where we get the logarithmic energy barrier. And you can see the first condition
13:00
was a deformability condition, which is expressed very nicely. And the second condition is something that we expect to happen. See, we are looking for quantum codes that does not have any string logical operator, right? And so it is only natural to assume that there is not any string logical operator with a width particularly equal to one. And what's amazing about this condition
13:22
is that there's this one extra simple condition that really combines all of them together and guarantees a finite aspect ratio. And so basically given a quantum code that is represented by these four parameters, you can easily check if they have, if they are absent of string logical operator.
13:42
There are a couple of observations that you can make. It turns out that the previous, the equations that I introduced in the previous slide does not have any solution when d is equal to two or d is equal to three. But it does have a solution when d is equal to five, which is the following. And it turns out that for sufficiently large number of d,
14:02
there's always a code that satisfies the condition. And also, most importantly, as I constantly advertise, these codes have a logarithmic energy barrier for logical error. And basically, even though Bravian-Haass result related was about a binary stabilizer code,
14:21
the idea behind proving the logarithmic energy barrier can be exactly extended in the same way. But there might be potential objections, which is that maybe there is no included qubit at all. Maybe that's why we didn't have any string logical operator. And fortunately, there is a nice response to that,
14:41
which is that at least for the anti-symmetric code, there is a one encoded qubit. And the way you can see this is that given n cubes, there are n physical qubits, and there'll be n generators. And there's at least one non-trivial constraint between the generators, which is to basically multiply everything. So take a look at this second generator here.
15:02
And if we multiply everything, for each vertex we have, for each symplexic pair alpha, we have the exact minus sign of that guy, which is alpha bar. So alpha times the generalized Pauli operator represented by alpha, and the generalized Pauli operator represented by alpha bar,
15:20
when multiplied together, becomes an identity. And the same thing for all, the rest of the three of the guys. So that corresponds to one non-trivial constraint on the code, so we'll always end up having at least one encoded qubit in this error correcting code. So how does a logical operator look like?
15:41
It's conjecture that there is a fractal logical operator. I have to admit this is something that I'm not completely sure about at this point. But when we change the system size, it turns out that the ground state degeneracy changes as the system size change. And apparently the commutation relation between these fractal operators seems to be very hard to compute. But there are very nice logical operators,
16:02
which are non-contractable surfaces, that have non-trivial commutation relations with each other. And they have a commutation relation with each other if the intersection lengths of the surfaces has, intersection lengths is not equal to zero, modular D, where D is the local particle dimension.
16:22
And these are the examples. So the normal vectors of the logical operators are in the X or Y or Z direction. So for instance, if we try to compute the commutation relation between this guy and this guy, it will depend on the intersection lengths between those two, which is a single line.
16:42
So to conclude, there is a large family of three-dimensional local codes resembling the properties of HOS code. So this tells us that HOS code is not just a fluke. This is a very general property, such as those kind of systems, which have logarithmic energy barrier, which have ground state degeneracy changes with system size, and logical operators that are either fractal or membrane.
17:02
But most importantly, they do not have any string logical operator. And I just want to mention that there is something that I didn't really introduce throughout the paper, which is that even though the theorem does not apply to D equals three code, there are actually some numerical evidences suggesting that there are some D equals C codes with finite aspect ratio,
17:21
to be more particular, finite aspect ratio with three, but I couldn't prove it. So it'll be desirable to have a proof for that particular code. And it'll be also interesting to see other kind of codes on a different lattice with similar properties. Thank you.
17:40
So, questions? So you looked at Q pits at the vertices. Of course, Zhang Huan Has has two Q bits. Have you looked at like accommodations like that with a tensor product? Is your technique allowed? You look at like a Q bit, Q trick combination, for example, or two Q tricks?
18:00
Yeah, it's definitely possible, but I just wanted to start from the simple example. Actually, the initial motivation was this D equals three code that I mentioned in the last, and then I tried to generalize it to see if there are any codes that I can prove the same thing. But the general idea is, yeah, the idea for proving the absence
18:21
of string logical operator is quite general. It's just that, but it depends on, but whether I can prove it or not depends on the parameters of the code. So yeah, I'll have to see, actually see the code to see if I can come up with something similar or not, but the method is quite general, yeah. So your method should then easily or not easily
18:41
then be able to look at Q bits and Q trick combinations? So basically, the way I prove this is to map the problem into a linear algebra problem, which is basically a rank of certain matrices, matrix. And reducing to that problem is trivial. It's the same. But given that matrix, counting the rank
19:02
might be an easy problem or may not be an easy problem. So that's where the difficulty is coming in. I see. Thanks. Other questions? The speaker.
Empfehlungen
Serie mit 3 Medien