Universal topological phase of 2D stabilizer codes
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 48 | |
| Author | ||
| License | CC Attribution - NonCommercial - NoDerivatives 3.0 Germany: You are free to use, copy, distribute and transmit the work or content in unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/35331 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
00:00
Codierung <Programmierung>Data structureTheory of relativityCollaborationismMachine codePhysical systemOperator (mathematics)Data structureQubitQuicksortConstraint (mathematics)Error messageNetwork topologyInformationFormal languageSpecial unitary groupLecture/ConferenceComputer animation
01:30
Invariant (mathematics)FamilyPhysical systemSystem callMetropolitan area networkSurfaceMultiplication signCASE <Informatik>Sound effectMachine codeQubitBoundary value problemComputer animation
02:21
TopologyError messagePerspective (visual)Execution unitLinear subspaceSpacetimeOrder (biology)Model theoryCategory of beingGame theoryNetwork topologySummierbarkeitStability theoryFood energyMachine codeVideo gameAerodynamicsMultiplication signDependent and independent variablesFamilyEmailDistanceCellular automatonComputer animation
03:24
TopologySocial classQuantum circuitConnected spaceLogical constantUnitäre TransformationPhase transitionSocial classBit rateElement (mathematics)EvoluteOrder (biology)Quantum circuitLocal ringLogical constantPhysical systemExistenceUnitäre GruppeBitFile formatComputer animationLecture/Conference
04:08
Pattern languageRange (statistics)Quantum entanglementCodierung <Programmierung>TopologyEvent horizonRhombusOperator (mathematics)Pattern languageWindowSocial classQuicksortMachine codeQuantum entanglementState of matterNetwork topologyOrder (biology)Phase transitionComputer animation
04:47
Phase transitionEquivalence relationLocal ringData structureTopologyCodierung <Programmierung>CollaborationismTwo-dimensional spaceAdditionOrder (biology)Data structureLinear subspaceMachine codeNetwork topologyDoubling the cube
05:26
Machine codeCodierung <Programmierung>System programmingString (computer science)Machine codeTheoryProcess (computing)Interactive televisionCASE <Informatik>Line (geometry)Computer fontForm (programming)Algebraic structureSurfaceFinite-state machineData structureDirection (geometry)Thermal conductivityCycle (graph theory)Group actionSet (mathematics)Computer animation
06:35
Social classSimilarity (geometry)TheoremPhase transitionControl flowFiber bundleEquivalence relationSet (mathematics)Object-oriented programmingConfiguration spaceNetwork topologyComputer animation
07:32
String (computer science)Operator (mathematics)Machine codeProduct (business)Element (mathematics)Rule of inferenceParity (mathematics)NumberDirection (geometry)Link (knot theory)String (computer science)Hamiltonian (quantum mechanics)Decision theory1 (number)TheoryVisualization (computer graphics)Interactive televisionTerm (mathematics)Duality (mathematics)CASE <Informatik>Event horizonProcess (computing)Sensitivity analysisMusical ensembleElliptischer PseudodifferentialoperatorSystem callRight angleMoment (mathematics)Asynchronous Transfer ModeTwitterDialectLattice (group)Streaming mediaCycle (graph theory)Computer animationDiagram
10:22
StatisticsModel theoryOperator (mathematics)Machine codeString (computer science)Rule of inferenceQuicksortInteractive televisionMessage passingLine (geometry)ResultantProcess (computing)Product (business)Network topologyCommutative propertyCASE <Informatik>Type theorySign (mathematics)ChainLink (knot theory)Model theorySpecial unitary groupCategory of beingMultiplication signEvent horizonStudent's t-testSurfacePoint (geometry)Open setDifferent (Kate Ryan album)VotingVector spaceSound effectComputer animation
12:41
LTI system theoryElectric generatorTranslation (relic)Local ringInvariant (mathematics)TopologyGroup actionError messageLattice (group)Single-precision floating-point formatFamilyInfinityMachine codeStability theoryGroup actionNetwork topologySystem callPlanningCategory of beingLocal ringError messageState of matterVector spaceComputer animation
13:30
Group actionTopologyLattice (group)Theory of relativityComputer simulationCondition numberSelf-organizationFamilyElement (mathematics)Message passingInfinityStability theoryCentralizer and normalizerMachine codePhase transitionInvariant (mathematics)Computer animation
14:36
Clifford algebraEquivalence relationAddressing modePerspective (visual)QubitOperator (mathematics)Model theorySingle-precision floating-point formatInvariant (mathematics)Phase transitionKey (cryptography)Stability theoryTranslation (relic)String (computer science)Local ringMappingMachine codeLattice (group)Group actionCentralizer and normalizerGene cluster1 (number)File formatCASE <Informatik>Computer animation
15:54
Equivalence relationModel theoryInfinityMachine codeStability theoryGroup actionTwo-dimensional spaceResultantNetwork topologyMachine codeFinite setProof theoryOperator (mathematics)Design by contractNumberVotingComputer animation
16:32
String (computer science)Operator (mathematics)Model theoryElectric generatorIndependence (probability theory)LTI system theoryComputer fontProof theoryStability theoryQubitString (computer science)Machine codeCentralizer and normalizerSet (mathematics)Single-precision floating-point formatCorrespondence (mathematics)Symplectic vector spaceMappingModel theorySoftware frameworkCategory of beingIndependence (probability theory)Series (mathematics)NeuroinformatikNumberOperator (mathematics)Lattice (group)Lattice (order)Observational studyResultantPhysical systemSign (mathematics)Execution unitInternetworkingLaserPattern recognitionProof theoryConnectivity (graph theory)Doubling the cubeComputer animation
18:31
WebsiteString (computer science)Operator (mathematics)WebsiteOperator (mathematics)BitString (computer science)Set (mathematics)MereologyReading (process)Computer animation
19:15
Model theoryCycle (graph theory)Right angleNetwork topologyPlanningMachine codeString (computer science)StatisticsStability theoryCommutatorPoint (geometry)Computer animationDiagram
19:58
Model theoryElectric generatorMachine codeAxiom of choiceString (computer science)Independence (probability theory)Correspondence (mathematics)Group actionModel theoryNumber1 (number)Canonical ensembleMereologyStatisticsSet (mathematics)Vertex (graph theory)CASE <Informatik>Execution unitFamilyDependent and independent variablesComputer animation
21:02
String (computer science)Software frameworkModel theoryIndependence (probability theory)Commutative propertyFinitary relationString (computer science)CommutatorOperator (mathematics)Model theoryLattice (group)WeightCASE <Informatik>Sound effectLimit (category theory)Basis <Mathematik>Data independenceComputer animation
21:52
Commutative propertyFinitary relationIndependence (probability theory)Model theorySoftware frameworkString (computer science)Procedural programmingOrder (biology)Software testingLaserMachine codeElectronic mailing listFamilySingle-precision floating-point formatQubitStability theoryLevel (video gaming)String (computer science)Computer animation
22:34
Computer fontMachine codeCodierung <Programmierung>Gauge theoryLocal GroupCASE <Informatik>Public key certificatePhysical systemAssociative propertyLinear subspaceQubitGauge theoryCondition numberGroup actionStability theoryAdditionSound effectTheory of relativityPhase transitionGoodness of fitSoftware frameworkBounded variationComputer animation
23:21
TopologyCodierung <Programmierung>Error messageStability theoryNetwork topologyMachine codeGauge theoryFamilyGroup actionTheory of relativityCondition numberCASE <Informatik>Finite setCentralizer and normalizerPolygonOrder (biology)CommutatorOperator (mathematics)AdditionLogic gateGradientSoftwareNumberPoint (geometry)Computer animation
25:13
Gauge theoryCommutatorMorphismusString (computer science)Gauge theoryGroup actionState of matterQuicksortCommutatorOperator (mathematics)QuotientVortexTerm (mathematics)Arithmetic meanOrder (biology)Stability theoryInteractive televisionMorphismusBitConfiguration spacePolygonCASE <Informatik>StatisticsSet (mathematics)Network topologyModel theoryFiber bundlePhase transitionSocial classMachine codeEquivalence relationAbstractionTotal S.A.Streaming mediaTheory of relativityView (database)Closed setElectronic mailing listLogic gateStaff (military)Beta functionElement (mathematics)NumberInformationMorphingComputer animation
28:34
MorphismusGauge theoryLevel (video gaming)CircleStability theoryAxiom of choiceMedical imagingShape (magazine)Event horizonTheory of everythingWebsiteSingle-precision floating-point formatCycle (graph theory)Computer animation
29:28
Electric generatorDuality (mathematics)Stability theoryGauge theoryDuality (mathematics)Medical imagingCanonical ensembleSet (mathematics)CASE <Informatik>NumberLinear subspaceMultiplication signFrequencySineComputer animation
30:56
Model theoryTopologyMachine codeTorusElectric generatorPoint (geometry)View (database)Gauge theoryType theoryQubitMachine codeTorusExclusive orStatisticsNetwork topologySingle-precision floating-point formatModel theoryStability theoryInheritance (object-oriented programming)Software testingObservational studyQuicksortString (computer science)FrequencyRoutingCASE <Informatik>Computer animation
32:17
Software frameworkString (computer science)Gauge theoryElectric generatorOperator (mathematics)Stability theoryGauge theoryLattice (group)Software frameworkHomologiePhysical systemMachine codeString (computer science)QubitTorusHomologiegruppeBasis <Mathematik>Form (programming)CASE <Informatik>Term (mathematics)Set (mathematics)Extreme programmingMusical ensembleLogic gateTheoryBitComputer programmingGroup actionDependent and independent variablesQuicksortAdditionStandard deviationSystem callComputer animation
34:45
Data structureSoftware frameworkString (computer science)Model theoryQuantum entanglementPattern languageCodierung <Programmierung>Range (statistics)TorusBoundary value problemTopologyTerm (mathematics)Machine codeNetwork topologyTwo-dimensional spacePhysical systemOperator (mathematics)Phase transitionProof theorySoftware bugCondition numberSet (mathematics)Centralizer and normalizerFlow separationExpressionDifferent (Kate Ryan album)Standard deviationGroup actionInfinityElement (mathematics)Bound stateLattice (group)Boundary value problemEntire functionStability theoryDistancePoint (geometry)Clique-widthLocal ringLimit (category theory)Codierung <Programmierung>FamilyCategory of beingUniverse (mathematics)Wave packetMusical ensembleTopologyInclusion mapNumberAngleModel theoryArithmetic meanLibrary catalogCASE <Informatik>Decision theoryQuicksortSound effectComputer animationLecture/Conference
Transcript: English(auto-generated)
00:00
topological phrasing to destabilize our codes. So thanks, Daniel, for inviting me to this nice conference. This is a work that is a collaboration with David Poulin, who couldn't make it to this conference in the last minute.
00:22
And one of his students, Guillaume Duclosiancis, who will be giving a related talk on Friday. So this talk is about topological codes. And well, since although we have already heard about them, let me remind you that the idea that in a topological code,
00:42
qubits are in some sort of minifold. And such codes, the check operators that we need to measure to recover the error syndrome are local, so that they just involve a few neighboring qubits. And at the same time, critical operators
01:01
have a global nature, so that any operator that has a support in a region that doesn't see the global structure of the minifold won't be able to recover any information about the encoded states. So in this talk, I want to take a systematic approach
01:21
towards these codes and try to understand under certain constraints what is the general structure. So in particular, I will be focusing on two-dimensional systems, which are traditionally valid in a certain sense and defined by qubit systems with established codes.
01:47
So topological codes are given as families of codes. And in all the examples that we have, the code will have some bulk.
02:03
And then maybe there will be boundaries and other defects. But it's always the case that this bulk is translationally invariant. So our approach is to classify codes according to this book, so that we can forget about all these different defects and so on.
02:23
Now, of course, such codes are closely related to topologically ordered models. So in particular, I can consider such a Hamiltonian, which is a sum of the stabilization generators. And the idea is that the ground state corresponding
02:43
to all these guys having a game value 1, so that the ground state, or the space of ground states, it corresponds to the code subspace. And the excitations correspond to error syndrome. So whenever one of these negative are in value,
03:01
I will have an excitation with two units of energy. The ground state is, of course, the generate, just as the code. And from this property of topological codes, we get that the ground states are locally indistinguishable. So basically, this is a property
03:21
that defines topological order. And there is a nice perspective on topological order introduced by Chen-Gu and Wen. So what they say is that topological order describes the equivalent classes defined by local unitary evolution. Let's see what they mean by this. So what they argue is that if we
03:41
have two-gapped ground states, they will be in the same phase, suddenly, they can be connected adiabatically without closing this gap. And then this amounts to them to be connected by local unitary transformation, or for us, to the existence of some quantum circuit
04:02
of constant depth, constant in respect to the size of the system. OK, so more pictorially, what they are saying is that in order to classify topological codes or topological order, what we are doing is classifying long-range entanglement patterns.
04:22
So for them, a short-range entanglement pattern is one, so it's some state that we can transform for local operations into a product state. And other states will have long-range entanglement,
04:40
and these long-range entanglement will be defined by these equivalent classes of two local transformations. So we have two main goals. The first is to understand the structure of two-dimensional topological stylizer codes, including the subsystem codes that are not so closely related to this topological order that I was discussing.
05:03
And then in addition for subspace codes, which have the Hamiltonian analog, we would like to see that whenever they have the same structure, in a certain sense, we can transform one into another through local transformations, as we
05:21
showed according to this prescription by Nguyen and collaborators. So here's the outline. I will start explaining the role of onions in the theory code very briefly. Then I will go to the main result, which is that the theory code is somehow universal for two-dimensional codes.
05:41
And then I will jump to subsystem codes which have quite a nice algebraic structure. OK, so what is special, well, there are several things special about two-dimensions. But one of them is that there are two logically distinct ways to exchange two particles, either identical or not.
06:03
And so the idea is that if I extend them in this way, I cannot, the two processes cannot be the form one into the other without the word lines crossing. So this gives rise to the possibility that there could be some topological interaction that
06:22
distinguishes between these two paths. And the particles that are subject to such topological interactions are called onions. So the simplest case is that of abelian onions, which are all we need. And such bundles are described by three elements.
06:48
So we have, first of all, a set of topological charges. These charges are equivalents of excitations.
07:01
So if I take a given region and I have a given configuration of excitations, I could apply some local transformations and get another set of excitations. And as I move, as I do this information, I will move in a second equivalence class. And these are the labels for these equivalence classes.
07:21
So that charge is something that is conserved in a region unless it's exchanged with some other outside region. So the second, oops, sorry, oops. So the second element will be fusion rules that tell us what is the total charge given
07:42
of two regions, given the individual charge of each of them. So in the abelian case, this amounts to basically a product. So the decision rules will tell me what is the total charge given these two charges. And finally, there are some gradient rules
08:02
that tell us what happens as long as topological interactions are involved when I assign two onions in one of the two possible ways. OK. So let's see this in this very relevant example, which
08:21
is the Kita story code. So I would like to emphasize that in theory code, we can visualize Pauli operators, which are products of x and z, graphically, so that an x will correspond to a direct link and a z to a dual link, linking the dual lattice.
08:41
And this way, both kind of terms in the Hamiltonian or check operators, we can be regarded as plaquettes. So two kinds of excitations in this model,
09:01
we have excitations in dual plaquettes that can be created by such sine operators, which are products of x operators here. So the idea is that whenever I apply such a string, I will not sense the even or odd number of,
09:21
whether it's an odd or an even number of such excitations. And similarly for the direct plaquettes, sorry, this would be a direct plaquette. It's neither a dual or a direct plaquette. OK, and the idea is that total there are four charges. So I could have an even number of both dual and direct
09:41
excitations. Then I'm in the trivial sector. If I have an odd number of the dual ones, I say that I have an electric charge. If the odd number, if I have an odd number of direct ones and even number of these, I have a magnetic charge. And then finally, there is a cut, which corresponds to a case where I have an odd number of both.
10:00
So basically, this already includes the fusion rules because any charge composed with itself will give me the trivial sector. And I only need the topological interactions. So to recover them, we can use the fact that these charges are created as endpoints of these strings
10:23
and recover the topological interactions from the commutation properties of the string operators. So if this is a sort of, let's see, I guess, magnetic string and this is an electric one, they will anti-commute. And then I can consider two processes. That are a product of these string operators.
10:41
And when seen in time, developing in time, one of the processes describes, so in both cases, the two, the electric and the magnetic charges ends in the same place. But in one case, the paths are, the work lines are linked, in the other case, they are not. And we can see that a minus sign appears
11:00
differentiating the two. So this tells us that these two targets have R-semunes, okay? And then, we similarly can recover the self-statistics or topological spins, which tell us what happens when they exchange two targets of the same type.
11:21
So in this case, we will need three strings with a common endpoint. So in the case of electric and magnetic charges, they are boson, so it's not a lot of fun. But the composite turns out to be a fermion and this can be checked this way. So, notice that the composite will be moved from one place to another through such a chain operator,
11:43
which is the product of an electric and a magnetic string. And I take three of these and then, by the ideas that I have, and you hear one and you hear, and then by ordering these operators in two different ways, I can either exchange the two excitations,
12:04
or leave them where they are. And the difference, again, is a minus sign. Then, of course, they are fermions because when you exchange fermions, you get a minus sign. Okay, so the main message is that we have some Hamiltonian or some code and we have extracted and abstracted a new model from it.
12:23
In this case, we have four charges, the diffusion rules that correspond to the C2 and C2 group, and then some braiding rules. And everything can be recovered from the string operators. This is the main message. Okay, so now I can jump to the main results.
12:43
So first thing that we need is to abstract ourselves from a family of topological codes to a single stabilizer group that's defined in an infinite lattice. So for this family of codes, there will be some recipe to construct the bulk
13:01
and we just apply it to the infinite lattice. Now, of course, this resulting stabilizer will have some properties because it comes from a family of topological codes. It cannot be just any stabilizer. And we must remember that in a topological code,
13:23
local and detectable errors should not affect the encoded states. In other cases, it wouldn't be topological. And let's see what that translates into. So if I have some polypator here in the infinite lattice and it combines with all the stabilizer generators,
13:41
we can find an element of this infinite family of codes that is big enough so that this guy fits in the bulk. And then it will also belong to the centralizer of the stabilizer from which it follows that from this code being topological
14:02
that p itself belongs to the stabilizer. And then, well, without going into details, it's possible to show that either p belongs to the stabilizer here or we can assume that it does actually. Okay, so the message is that we have this condition
14:21
that the centralizer of the stabilizer is up to phase of the stabilizer itself. And this is the topological condition that we impose. So these are the two ingredients, translational invariance and this topological condition. And then we want to classify all these guys. So we seek to be able to relate codes
14:42
through local transformations. And indeed, it turns out that it's enough to consider the following ones. First, we have a cross-graining of the lattice, which basically amounts to doing nothing. It's just looking at the lattice from a different perspective. We have a local and translational invariant key for mappings so that we map the polygroup to itself.
15:02
In fact, locally, in this case, in the evening light, it follows from the translational invariance, given that I am only considering the polygroup to consist of operators with a final support. And then finally, I would like to be able to add and remove disentangled qubits.
15:21
So qubits that have their own single qubit stabilizer so that from the perspective of the topological code, they are not interesting. Okay, so it's easy to see that given these three transformations by combining them, one will, so if my code has a certain annual model, suppose,
15:43
then this annual model will not change to this transformation simply because it's described with the string operators that can be arbitrarily large and so on. But the interesting thing is that the contract is also true, and whenever two codes have the same annual model, they can be transformed one into the other
16:01
through these basic operations. Then, if we rule out the possibility of so-called kaia-annions, which we can do according to the guitar, then one arrives to the conclusion that, but I will give more details, that every two-dimensional topological stabilizer group
16:21
in this sense is locally equivalent to a finite number of copies of the toric code, which is our main result. So let me give some clues about the proof of this. So well, first of all, there are two technical, boring results, but very important.
16:41
So first, that in 2D, for these stabilizer groups, we can find a set of independent generators, okay? So that if you translate it into the symplectic vector space formalism, I'm just saying that there are no linear constraints between them.
17:01
So the thing is that in 2D, we can find such a local and translational invariant independent generators, and this is actually not true in 3D. And if it is true, I mean, it, in the proof, it also, we also use the fact that these stabilizer are the centralizer of something actually of themselves. So if that was not the case,
17:21
maybe it wouldn't be true, this property. It can be not true. So this is the first technical thing. The second technical thing is to show that the number of charges is finite. And once you have this, it's very easy. You just obtain the annual model by constructing the string operators
17:40
and checking what are the, you know, computation properties and so on. And then once you have these string operators, you construct a framework, a series of lattices made of string segments, we'll see how. And the framework of string segments, the resulting plaquette stabilizers are, give all the generators for the stabilizer,
18:04
give all the generators for the stabilizer that have charge, and then the rest of generators have no charge, and then the mapping between two codes where we have done all this would amount to map these string segments to the corresponding string segments with the same charge, and all those extra and charged stabilizers,
18:23
we map them to single qubit stabilizers. So they are decoupled from the code. So some small details. So first of all, we need to cross-create the lattice till at any site we can find any possible charge
18:44
until whenever we have two sites with excitations here in this site and this site with a given charge that is equal, and we can pass it to them. If we cross-create enough, we are going to be able to construct an operator with support in this gray region here,
19:02
so just a bit thicker than the path, such that it creates these two excitations. So this is what we mean for a string operator here. We can define them for arbitrary paths. And once we have string operators, we can recover motorized statistics and the vertical spin
19:22
with a trick that I already explained for the third code. And to see that this actually makes sense, consider for example that we have these two pairs of strings. So they should have the same commutator, right? And to check it, we can extend the picture of it. And now, I have these closed strings.
19:43
Since they have no endpoints, they create no excitations, so they belong to the stabilizer up to a phase. And therefore, the two of them commute. The two commutators are the same and thus, this guy here is well-defined. It's independent of the choice of the strings.
20:02
And similarly for this other guy here. Good, so once we have our new model and the vertical interactions, we can find a set of canonical generators for the group of charges.
20:22
And this is what one finds. So there will be a certain number of pairs of generators, each of them. So this starts here, we'll have some unique motorized statistics with this other guy and neither of them interacts with any other generator.
20:42
And then, all of them are bosons as that maybe the two last ones which could be both fermions. Now then, each of these pairs corresponds to the anions in the vertical. Okay, so we have several copies of the vertical and then maybe this kind of part which, so then in any case,
21:04
we can construct several lattices of operators. Okay, so this will be large operators after all the course grading and everything. We'll have some string operators here forming a square lattice for each charge and each of these lattices. So they are displaced with respect to each other.
21:23
And the reason to do so is that we want the commutators to depend between all these string segments. We want them, these commutators to depend only on the annual model, not on details of the strings. Okay, so that's the reason to do it that way.
21:40
So we end up with this collection of string segments that have commutators that are independent of the original model, only the model. And then, in order to do the mapping, we will just, so here we have two codes.
22:00
In each of them, we list all these procedures so we arrive to these lattices. And then, for each lattice, so for example, I will have this first, say, electric charge and the corresponding one in the other code. And I will map string segments to string segments. And then, it's possible, so there will be,
22:22
apart from the stabilizers coming from Plaquettes, I will have other stabilizers, but they have no charge. And they can be mapped to single qubit stabilizers. I will not go into any more details. So let me move on to the subsystem case. So, well, we have heard of this, but just very fast.
22:43
In a subsystem code, rather than encoding in a subspace of the Hilbert system, we will just take a subsystem, these are our logical qubits, and then each qubit about which we don't care. And in the case of, in the stabilizer formalism, as described by Polan, we still describe
23:00
our subspace through a stabilizer. But then, in addition, we have a gauge group whose action doesn't alter, doesn't affect in coded states. And the important thing is that the stabilizer and the gauge group are related through this condition so that, up to phases, the stabilizer is the center of the gauge group.
23:22
Now, in the topological case, what we mean for a topological stabilizer subsystem code will be a family of codes, each with a stabilizer and a gauge group. And both of them have local generators. Now, again, we want to extract the recipe for the bulk and put it in an infinite lattice
23:41
and obtain some stabilizer and some gauge group. As before, we want to impose a topological condition in this case. And in this case, whoops, in this case, if I have poly operator here that commutes with all the stabilizer generators,
24:00
when I carry it to a large enough code, it will also commute with all of them. Therefore, it will belong to the gauge group now. And one can see that, again, this in place that we can assume that the gauge group here contains this poly operator. So we are left with this condition,
24:20
that the gauge group is the centralizer of the stabilizer. So it contains all the poly operators that commute with the stabilizer generators. But once we have this condition, we could just as well define the gauge group through it. And then we get a condition on the stabilizer
24:42
that guarantees that our, well, not guarantees, but that we need in order to, that becomes our topological condition, right? So it doesn't engage group anymore. And it's that the centralizer of the stabilizer, of the stabilizer, it's in a sense the stabilizer of the phases. So of course, this would be trivial in a finite,
25:01
for a finite number of qubits, but it's not necessarily true in the case of an infinite light. So the main obstacle to move to such gauge codes from such phase codes
25:23
is that we need to generalize the notion of charge. So the trick is to make it a bit abstract. So remember that charge classifies equivalent classes of excitations up to trivial sets of excitations that can be created by applying some poly operator.
25:40
And this, we can extract a bit by considering that our configuration of excitations are actually, or if you want the syndrome, possible syndromes, with morphisms from the stabilizer group to C2. And the trivial morphisms will correspond to those that can be obtained as a commutator
26:02
with some poly operator. So this quotient will give the group of charges for the stabilizer. But now that we have this sort of slightly more abstract definition, we can generalize it immediately to the gauge group. We just substitute S with G, and we have a new group of charges,
26:23
well, that don't have the same sort of obvious meaning in terms of states or anything like that, but are very useful. And we still have the old charges for the stabilizer group. So we have two groups of charges.
26:40
And we could, as before, try to define topological interactions between them. So consider, for example, so in order for these interactions to make sense, remember that we have these three, these two closest operators that have to commute, so that it didn't matter which pair of strings I took to define the sort of interactions, right?
27:03
So consider, for example, that they have a, that the charge of these strings came from the, from gauge charges, right? So it's a gauge charge. So in that case, having a closest string means that this guy will commute with all the gauge operators,
27:21
and therefore it will belong, this closest string will belong to the stabilizer. Similarly, if I have a string with a stabilizer charge, this means that the closest string will commute with all the stabilizers, and therefore it belongs to the gauge group. So in this case, the two strings commute, and the two commutators are the same.
27:42
This would also be true if I have taken two gauge charges, because then I will have two stabilizers, they commute. But if I laser charge another stabilizer charge, I will have two gauge elements, and then they don't necessarily commute, so I cannot define such topological interactions in that case. So what we are left with is that
28:02
for two gauge charges, we have the well-defined mutual statistics, we have topological spin, and we also have, whenever I have a gauge charge and a stabilizer charge, I also have this mutual statistics. But nothing else, so I don't have topological spin for stabilizer charges, nor interactions between them.
28:23
So really, I have an anion model for the gauge charges, and then I could regard this as some sort of vortices for these anions. So of course, I can map gauge charges to stabilizer charges simply because amorphism from G to C2
28:45
can be restricted to amorphism closer to C2. I will graphically depict this this way so that a gauge charge is a circle with some color, and then the image will have the same color and the square shape.
29:00
And it's, well, this is a natural amorphism, it doesn't depend on any choice of generators or anything like that. And it will preserve this commentator so that if I just pick up two gauge charges and I map one of them, I will get the same commentator. Of course, I cannot map the two of them
29:23
because then the thing in the other side is not well defined. And as in the case of SAS based codes, again, I can find a canonical set of generators for the gauge charges and for the stabilizer charges. Let me first discuss the gauge charges.
29:40
So we have first the sector that looks very much like what we've had in SAS based codes, several bosons, and then maybe a chiral pair that now can actually appear. And in addition, we have something new. We have several bosons and maybe one fermion,
30:01
all of them non-interacting. So they are not anions. And then for the stabilizer charges, we can find the same number of generators. And this is because actually there is a duality between the two. So this would be ordered in a different way. So the thing is that this stabilizer charge
30:23
interacts only with this guy, but not with any other one. Similarly, the black one here with the red one here. So one for these guys. And then I have these stabilizer charges that are not the image of anybody here. And they are dual respectively to the charges
30:43
with the same number. Through the morphism, if you want this, I'm up to the trivial charge in the stabilizer. So there are many annual models that we could have.
31:01
But all of them can be obtained by combining four basic ones. So the first of them correspond to what we find in the Tory code with these two bosons with some unique mutual statistics. Then the second one is the same, but with two fermions so that the three
31:23
non-trivial charges are fermionic. And this can be found in topological subsistent color code that we discussed by Robert yesterday. We could also have a single boson. This can be recovered from what I call the subsistent Tory code, which would be a Tory code where to the stabilizer
31:42
we have to get the gauge group, we have all single qubit XOR C operators, whatever you want. And we can also have a single fermion. And this is what we get if we look at the key types. Honeycomb model has a subsistent code.
32:01
So in these two cases, actually, we have no encoded qubits. OK, but this fits into the classification. And actually, it's important to keep it, even though it's not useful from the encoding point of view. So once again, we can construct
32:20
a framework of sine operators. And we would like to recover the stabilizer and gauge generators as plaquettes of these lattices. And we can do so. So in the case of the gauge group, it's possible to find a set of generators for the gauge that
32:42
include these plaquettes. So this would be coming from the lattice that where strings have this chart. And this is the dual chart. Well, I should better say conjugate this case. So the thing is that this is the chart of this plaquette
33:01
in this basis and this set of generators, similarly for this one here. And then we also have generators that have these charges which are not anionic. And they come from plaquettes made up
33:23
with strings that have a chart that corresponds to these guys that were dual to these other guys. And similarly for the stabilizer. So the idea is that the rest of generators, of either the gauge or the stabilizer,
33:41
will have a trivial chart. So the idea is that with this, we put the codes in a standard form. And therefore, we can see that all codes can be understood in terms of these anions. In addition, we could put this lattice back
34:02
into a finite system like a torus. And then one sees what you expect that you will have, again, that the homology gives you the local operators and so on. So each of these pairs will contribute to qubits in the code in the torus. And these guys contribute nothing.
34:21
And in addition, they have a problem is that when putting in a finite lattice, we need to add either a gauge or a stabilizer generator that are global. You need to add one pair, one of these generators, and pair a non-trivial generator of the first homology group.
34:45
Yeah, so the lesson is basically this, that we can understand two-dimensional topological system codes in terms of anions. And yeah, so with that, let me just leave some questions. So first of all, we have been considering just the bulk.
35:01
But we could also look at the defects in the codes. So we could have a code with several different bugs put together. Or either of these could be just back in the end of the code. So we have boundaries, and we have point defects. But we can also classify this potentially using this tool. So we could go to a setting where
35:21
we have two semi-infinite planes, each with different, representing different bugs. So this is translationally invariant. Then we have a boundary that is translationally invariant in this direction, and then we have some point defect. And this way, we could classify all such possible things up to local transformations and so on. Of course, we could consider more general
35:40
two-dimensional codes. And finally, maybe the most exciting is going to 3D. Because as we learned this morning, there are much more exotic things waiting for us there. So the classification is more than just homology.
36:01
So that's it. Thank you. So questions? I have a question. So what's the defining property of the 2D topological
36:21
stabilizing code? So do you assume the locality of the operator and find the distance? Because you didn't specify it at the beginning. So all you impose is the locality of the stabilizer generators. So you will have a family, and then you impose that.
36:41
Any operator, so you could do it in different ways. But the idea is that there will be always a large code in your family. So when you go to large enough number, where any operator will be local in the sense that it doesn't affect that. And so your coarse-grained operators are limited in widths by their distance.
37:01
So the coarse-graining we only do in the infinite lattice and so on. Yes, but they are limited in size by the locality of the stabilizer generators. You mean whether? What's the limit on the required coarse-graining? Oh, OK.
37:20
Let's see. So there is a limit, but I cannot tell you. There are many steps in the proof that are just like, OK, there is some coarse-graining that will give you this. But it's a bit involved. So you can put a bound on what coarse-graining you are going to need depending on the size of the generators.
37:41
But I cannot tell you the expression. It is possible to give it. For the standard stabilizer case, was the condition that the centralizer of the stabilizer is modulo faces the stabilizer?
38:00
In the infinite lattice. Yeah, so yeah, that's exactly what I'm asking about the encoded operators. Do you put a size on the entire group or elements of bounded size? So encoder operators will appear when you go back to some finite code,
38:22
but not, of course, in the infinite lattice. So the infinite lattice is just a picture. The idea of going to the infinite lattice is that everything becomes local. So everything is automatically local. So you don't have to care about. That's why I wasn't careful in defining locality or anything. So the thing is that whatever definition you take,
38:40
it will basically work. And then once you go to the infinite lattice, everything is local. And then it's easier, I don't know. OK, thank you. Other questions? The speaker.