Fault-tolerant quantum computation with high threshold in two dimensions
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/35304 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
12
23
24
29
31
37
38
00:00
BitPhysical systemImplementationError messageQuantum computerNetwork topologyQubitFault-tolerant systemComputer architectureTwo-dimensional spaceType theoryLattice (group)Pointer (computer programming)Set (mathematics)Set (mathematics)Constraint (mathematics)Fehlererkennung
01:53
ArchitectureAtomic numberDistanceLattice (group)Charge carrierOpticsCylinder (geometry)Interactive televisionSet (mathematics)Computer architectureConstraint (mathematics)Logic gateArray data structureQubitLocal ringCASE <Informatik>Range (statistics)Two-dimensional spacePhysical systemComputer animation
03:22
Quantum computerMilitary operationLogical constantData miningGroup actionThresholding (image processing)Scaling (geometry)Invariant (mathematics)Translation (relic)Set (mathematics)Thresholding (image processing)Quantum computerError messageResultantTheoremEndliche ModelltheorieFault-tolerant systemQubitQuicksortAreaSlide ruleOpticsDigital electronicsOperator (mathematics)Physical systemDot productMereologyExtension (kinesiology)Computer configurationGradientComputer fontLattice (group)Computer animation
05:20
CodeSurfaceTopologyComputer fontMeta elementTwin primeInteractive televisionNetwork topologyComputer architectureElement (mathematics)SurfaceConstraint (mathematics)Constructor (object-oriented programming)CodePhysical systemSet (mathematics)Computer fontField (computer science)Set (mathematics)Goodness of fitGeometryGroup actionDimensional analysisData structureLecture/Conference
07:07
Quantum computerSurfaceQuantum field theoryMenu (computing)Commodore VIC-20CodeChainLattice (group)Logic gateSurfaceSet (mathematics)Correspondence (mathematics)WebsiteCodeStreaming mediaComputer iconMathematicsWave packetForcing (mathematics)Internet forumSigma-algebraOperator (mathematics)Execution unitSineType theoryString (computer science)Multiplication signQuantum computerBoundary value problemRight angleStability theoryCommutatorNumbering schemeNetwork topologyLattice (group)Electric generatorComputer-assisted translationConstructor (object-oriented programming)Latent heat10 (number)PolygonCASE <Informatik>Shape (magazine)Product (business)TensorproduktComputer architectureSet (mathematics)HomologiegruppeFehlererkennungAdditionDifferent (Kate Ryan album)1 (number)Goodness of fitQubitComputer animation
12:15
CodePlanar graphError messageTopologyStatistical mechanicsQuantum computerCodeFehlererkennungTheoryAlgorithmProcedural programmingCommunications protocolSurfaceSet (mathematics)AdditionHomologieEndliche ModelltheorieStability theoryTerm (mathematics)ChainNetwork topologyClassical physicsObservational studyPhase diagramRandomizationConnected spaceHypermediaPerfect groupMaxima and minimaMultiplication signSystem administratorBitStatisticsComputer animation
14:47
QubitChannel capacityCodeSurfaceTopologyCausalityPlane (geometry)Duality (mathematics)FehlererkennungMoment (mathematics)CodeQubitHomologieSurfaceOperator (mathematics)Prime numberCubeComputer-assisted translationWebsiteSlide rulePlanningNumbering schemeBoundary value problemStability theoryDuality (mathematics)Binary codeComputer animation
17:25
CodeSurfaceBoundary value problemPlane (geometry)Duality (mathematics)ChainCrash (computing)ProgrammschleifeType theoryRule of inferenceString (computer science)CodeCubeQubitLoop (music)Boundary value problemComputer animation
18:33
Quantum computerCodeExecution unitTopologyTrigonometric functionsFinitary relationElement (mathematics)Mathematical singularityValuation (algebra)EmailThresholding (image processing)Error messageSurfaceCodePrime numberQubitData storage deviceMultiplication signFreewareElectronic signatureString (computer science)State of matterPolygonUniverse (mathematics)Configuration spaceEigenvalues and eigenvectorsRule of inferenceType theoryOperator (mathematics)Game controllerProcedural programmingTable (information)Constructor (object-oriented programming)Communications protocolPlotterOverhead (computing)Loop (music)Logic gateLevel (video gaming)Constraint (mathematics)Numbering schemeCharacteristic polynomialInverter (logic gate)Range (statistics)Information securitySemiconductor memoryPhysical systemThresholding (image processing)GeometryClassical physicsFault-tolerant systemComputerBitCubeDivisorPhase transitionError messageDemosceneTheory of relativitySlide ruleArrow of timeLocal ringNetwork topologyElement (mathematics)MeasurementRevision controlQuantum computerPropagatorMilitary baseMereologyHeegaard splittingFehlererkennungResultantSigma-algebraComputer animation
26:41
Error messageData modelMeasurementSpacetimeOverhead (computing)Thresholding (image processing)Numbering schemeQuantum computerPointer (computer programming)Logic gateState of matterError messageBit rateSlide ruleCurveType theoryFault-tolerant systemDrop (liquid)Communications protocolMessage passingScaling (geometry)ExponentiationOverhead (computing)ComputerBitProcedural programmingPoint (geometry)Constructor (object-oriented programming)CodeTerm (mathematics)Absolute valueDigital electronicsFunctional (mathematics)SurfaceThresholding (image processing)Numbering schemeLevel (video gaming)PlotterFigurate numberSet (mathematics)Office suiteMultiplication signDemosceneEndliche ModelltheorieMathematical analysisComputer scienceQubitDiagram
31:15
SurfaceSurfaceRootElement (mathematics)Uniform resource locatorMathematicsSet (mathematics)CodeCubeOperator (mathematics)Degree (graph theory)Network topologyConstructor (object-oriented programming)Transformation (genetics)QubitLattice (group)Hadamard matrixComputer animation
32:44
Moment (mathematics)Lattice (group)WebsiteString (computer science)Error messageStability theoryType theoryOperator (mathematics)CuboidQuicksortComputer animation
33:56
Different (Kate Ryan album)Constructor (object-oriented programming)Lattice (group)Film editingOpen setComputer animation
34:45
CodeExecution unitSimultaneous localization and mappingOperator (mathematics)Group actionBitCodeConstructor (object-oriented programming)Point (geometry)Electric generatorSigma-algebraRule of inferenceLattice (group)CommutatorType theoryStability theoryCASE <Informatik>Row (database)Film editingString (computer science)Uniform resource locatorPolygonTheoryMereologyFlow separationCategory of beingSoftware frameworkPhysicalismPlastikkarteSubsetProgrammschleifeCentralizer and normalizerPresentation of a groupMeasurementSemiconductor memoryTranslation (relic)Numbering schemeAmenable groupMathematicsAdditionWebsiteWave packetGoodness of fitGauge theoryQubitInformationComputer animation
41:06
CodeOperator (mathematics)Arrow of timeAdditionMereologyConstructor (object-oriented programming)PlastikkarteCodeState of matterBit rateInformationInsertion lossPolygonPhysical systemEigenvalues and eigenvectorsError messageStability theoryGoodness of fitMeasurementQubitSet (mathematics)Thresholding (image processing)Sigma-algebraComputer animation
42:58
Graph (mathematics)WebsiteQuantum computerQubitStatisticsStandard deviationConstructor (object-oriented programming)Vertex (graph theory)Phase transitionLattice (group)Numbering schemeQuantum computerOperator (mathematics)GodCodeMultiplication signSurfaceStability theoryBoundary value problemType theoryGraph (mathematics)Network topologyQubitSet (mathematics)Independence (probability theory)
44:01
String (computer science)Vertex (graph theory)TopologyCodePhysicsMereologyElement (mathematics)Electric generatorSurfaceCodeNetwork topologyQuantum computerString (computer science)Operator (mathematics)Link (knot theory)WebsiteSigma-algebraNumbering schemeGauge theoryRule of inferenceAdditionOrientation (vector space)Vertex (graph theory)Different (Kate Ryan album)Uniform resource locatorQubitStability theoryCASE <Informatik>Group actionPolygonDiagramFigurate numberPhase transitionPrice indexFerry CorstenLattice (group)Centralizer and normalizerDemosceneConstraint (mathematics)Computer animation
47:31
Rule of inferenceAnnulus (mathematics)TriangleElement (mathematics)String (computer science)CodeCentralizer and normalizerTable (information)SubgroupBijectionOperator (mathematics)PolygonLattice (group)Line (geometry)Phase transitionBitCubeTouchscreenIdentity managementSet (mathematics)WebsiteStability theoryAbstractionWave packetLevel (video gaming)Discrete groupPoint (geometry)QubitFlow separationWeightSigma-algebraGreen's functionComputer animation
50:27
String (computer science)Twin primeCASE <Informatik>BitSigma-algebraString (computer science)Operator (mathematics)PolygonStability theoryType theoryRing (mathematics)Quantum entanglementDifferent (Kate Ryan album)Numbering schemeMathematicsLogic gateCorrespondence (mathematics)Film editingMultiplication signStress (mechanics)PlastikkarteParity (mathematics)Lattice (group)Canonical commutation relationCodeElectric generatorSet (mathematics)Lattice (order)Centralizer and normalizerModal logicPosition operatorSurfaceOrder (biology)AreaQubitInfinitySign (mathematics)WeightComputer animation
54:28
Entire functionClifford algebraLocal GroupTrailExecution unitLogic gateString (computer science)Type theorySurfaceGreen's functionCodeMultiplication signElectronic signatureGroup actionConstructor (object-oriented programming)Operator (mathematics)DivisorSimulationPower (physics)Stability theoryInformationTable (information)Point (geometry)Overhead (computing)QubitClifford algebraEntire functionComputer animation
56:36
CodeExecution unitCodeAreaNetwork topologyConstructor (object-oriented programming)WhiteboardMathematical optimizationClifford algebraCubeSurfaceOperator (mathematics)MeasurementQuantum computerBitActive contour modelThresholding (image processing)Term (mathematics)AbstractionPermutationNumbering schemeAdditionOverhead (computing)Point (geometry)State of matterSlide ruleEntire functionDigital electronicsCombinational logicComputer architectureOptical disc driveDynamical systemAtomic numberOpticsArray data structurePole (complex analysis)DivisorDimensional analysisCarry (arithmetic)Link (knot theory)CASE <Informatik>Junction (traffic)Extension (kinesiology)Video gameLocal ringTrailDependent and independent variablesLattice (group)Computer animationLecture/Conference
Transcript: English(auto-generated)
00:03
So we're going to continue the discussion of fault-tolerant quantum computation with Robert Ralsendorf. Thank you. Mark, thank you very much for the introduction. Yeah, welcome to our third tutorial lecture on quantum error correction. We are getting a bit more specialized now. Namely, we will be talking about two-dimensional
00:21
architectures and fault-tolerant quantum computers with a geometric constraint, namely when only nearest neighbors can interact. OK, so what you see, I have to handle with two hands a micro pointer and a clicking device.
00:41
So let's see it. OK, but you recognize what this is. This is a coffee mug posing as a donut. And you know what that is. You think, well, that must be topological quantum computation. But it is not. We will be talking here about fault-tolerant quantum computation, a conventional setting.
01:01
So we are not naturally protected against errors. We have to do something to protect against errors in an active way. So our systems will be, per se, not topological. They will just be lattices of conventional qubits. But the methods that we choose to correct errors
01:21
in those systems will be topological. And what is certainly true is that the experimental setting or the type of qubit carries, the physical realization that we use to realize quantum computation will influence the architecture that we
01:42
are going to end up with and will influence the methods that we will use to implement fault-tolerant quantum computation and quantum error correction. So let me discuss this in slightly more detail. So for example, we could think of our being carried
02:00
by photons. Well, in that case, you are not likely to have a geometric constraint. Well, the most problematic things about photons is to have them interact. So you need to think about that. But your qubits, they could live anywhere. And then you could use optical fibers or whatever to shuttle between places.
02:22
So if you are discussing photons as your carrier of qubits, you can afford a global architecture. Everybody can interact with everybody else. Now if you move into other systems, like cold atoms and optical lattices or ion traps, now suddenly shorter distance gates
02:44
become preferable over longer distance gate. And well, something that would be very nice would be to have arrays of superconducting qubits. Well, the natural arena for those guys is to live on a cylinder on some other waiver.
03:00
So you are two-dimensional. And now local interaction or short-range interaction is very preferable. So you will be thinking about a local architecture. And I will make precise the local setting that I want to discuss here in this lecture. But before I get to that, let me just briefly remind you
03:22
what we need to know about fault-tolerant quantum computation for the purpose of this talk. And we've heard about it already in Andrew's talk. Let me just summarize very quickly. So fault-tolerant quantum computation is the art of keeping up a quantum speed-up in the presence of decoherence.
03:42
So decoherence is debilitating quantum computation. So you need to do something to prevent it. And we are in a very fortunate situation here. Namely, we can do something against decoherence in the circuit model and sort of system models.
04:01
And the very important or most important result in this area is the so-called threshold theorem. And it tells us that if we can manage to reduce the error per elementary operation below a certain threshold, then we can compute arbitrarily long and arbitrarily accurate.
04:24
So that leaves us with two questions. Namely, so what is this value? What is this threshold that we have to beat? And also, what's the operational cost of doing all this? And well, these are the two questions that I would like to address today
04:41
for this particular local setting. So let's go back to the setting. And let me specify what I will be talking about. So again, we are looking at a two-dimensional setting, say just a grid, often which only nearest neighboring qubits
05:01
are allowed to interact. And that is, as I said, relevant for superconducting qubits, quantum dots, optical lattices, and to a lesser extent, also for segmented ion traps, although here you have more options. So let me get back. I skipped the outline slide.
05:21
So let me go over that now. So I hope I just gave you the motivation for why I'm going to talk about those two-dimensional architectures. They are relevant in many physical systems. And what I'm going to do with my talk today is I just want to present to you two constructions, two
05:42
topological constructions for handling this geometric constraint of nearest neighbor interaction in two dimensions. So the first construction that I'm going to present to you is based on the so-called surface codes, which have been around for a couple of years now. And the other construction is considerably newer.
06:03
It's only about one year old, as being suggested by Hector Bambino, the so-called topological color subsystem codes. And this second construction is considerably more intricate. And therefore, I will just, between those two constructions, I just will pull out
06:24
several elements of the second construction, namely the twists, color, and subsystem codes, subsystem codes you have already heard about. And Todd's lecture this morning. And we'll discuss those aspects separately in simpler settings before we then get back and discuss
06:43
the full example. And I will conclude with some remarks. So that's the outline for my tutorial today. So yeah, so what I want to do with it is I want to show you structures. And hopefully, you can find some beauty in them. And maybe that inspires you to come up
07:02
with your own construction and maybe contribute to this field. So let me begin with the first of those constructions, which is based on the surface code. So the surface codes have been invented by Alexey Kitayev around 1997.
07:22
And they are stabilizer codes. More precisely, they are CSS codes, which makes them already nice. But then in addition, the stabilizer generators are close to local, which makes them very suitable for our architecture. And I will expand on that later.
07:42
So this is the first idea that goes in here. Those surface codes are perfectly suited for our two-dimensional nearest neighbor setting. But yeah, just error correction is just half of the story. We also need to think how to do quantum gates in such a setting. And it turns out that there is a topological way of doing
08:03
quantum gates in this setting. Namely, what we will be doing is we will be punching holes in the code surface, and this way creating boundary. And this will provide us with encoded qubits in that surface. And then we take those holes and move them around, fairly similar to what is done in topological quantum computing.
08:24
And by braiding those holes in the code surface, we will be able to realize topological quantum gates. So those are the two aspects of the construction that I would like to illustrate here in some greater detail. OK, so let me begin defining the surface codes.
08:43
So what we need for them is two-dimensional lattice with the qubits living on the edges of the lattice. So the qubits live here. What we next need to define for a stabilizer code
09:02
are the stabilizer generators and the encoded Pauli operators. So for CSS codes, the stabilizer generator come in two kinds, z-type and x-type. And the z-type stabilizers are associated with the plaquettes. Namely, we pick a plaquette, and then
09:22
the corresponding stabilizer generator is a four-fold tensor product of sigma z's on the edges around the plaquette, like this. And likewise, the x-type stabilizers are associated with the sites of the lattice.
09:40
And well, in fact, they consist of the tensor product of four Pauli operators, four spin-flip operators, sigma x, next to a site, like this. And you can easily check that all those operatively commute as they are supposed to. Am I holding the micro right?
10:00
Can you hear me from the back? Yeah? Is that OK? Good. Thank you. OK. So much about the stabilizer generators. Now, what are the encoded Pauli operators like? Well, in this surface here, where we have specific boundary conditions, I haven't talked about the boundary yet. I will do that later.
10:21
The encoded Pauli operators have a geometric shape, namely that of a string. So in case of the encoded Pauli operator sigma z, it runs from left to right across the entire lattice. And for the encoded Pauli operator sigma x, it runs from top to bottom across the entire lattice.
10:42
So now, what is topological about these codes? Well, so the first topological aspect that you see, we could consider different types of surfaces, say, without boundary, but homologically non-trivial ones with a genus, with a non-vanishing genus,
11:02
that is, with handles in them. And then it turns out that the number of qubits, encoded qubits that I can put into such a surface, depends only on the genus. That is, it depends only on the topology of the surface, but not on the size.
11:20
Another topological aspect that I find here with those codes is, well, I said this string of z's corresponds to the encoded z operator. z and z is confusing me. I hope both is understandable. Anyway, so it's not just that string. It could be any string that runs from left to right.
11:41
And in a more mathematical fashion, I can deform such a string in a homological fashion, that is, by adding the boundaries. And the resulting string would still represent the same encoded operator, sigma z.
12:01
So this encoded operator is represented by a whole homology class of strings. OK, so the quantum error correction
12:20
or quantum error correction with those codes is well studied. And you could ask, well, it's nice that they are already stabilizer codes. We know that as soon as we're dealing with a stabilizer code, a whole machinery of discussing quantum error correction becomes available to us.
12:40
But now we have this topological picture, this picture of homology in addition. So we may ask ourselves, is there anything in addition that we get out of this topological picture? And the answer is yes. And Andrew alluded to this before. We can map the success, or we may
13:01
discuss the success of quantum error correction in this setting in terms of a classical statistics mechanics model, namely the so-called random plaquette z2 gauge model. So we can study quantum error correction by drawing phase diagrams of those stat mech models, which,
13:20
of course, doesn't make it any easier. But it's a nice connection anyway. And also, as Andrew has pointed out, for this particular topological quantum code, the surface code, quantum error correction or the classical procedure needed to be run for quantum error correction is actually efficient.
13:41
And we have known this for a long time, this minimum perfect chain matching that Andrew alluded to is also known as Edmonds algorithm and dates back to the 1960s. So it has been, even before quantum computation, the necessary mathematical tools have been invented
14:01
to deal with this setting. But the error correction of the topological quantum codes is more difficult than this. And it's a very recent advance in quantum error correction theory that has led to efficient quantum error correction protocols for those other topological quantum
14:22
codes. And you will hear about this at this conference in two talks by Hector Bambin and Guillaume Duclos-Guillanchy from Sherbrooke. OK, that was a little detour. What I wanted to say is that the error correction for those codes
14:41
is well studied, and we have efficient algorithms for quantum error correction with them. OK, so let me now leave error correction for a moment and think about encode qubits in those surfaces. So as I already said, we can encode qubits by going to homologi-
15:01
oops, by going to homologically non-trivial surfaces. But maybe that's too complicated for experiment. So that's not what we want to do here. We want to stick with the plane. But the plane in itself does not offer the support for any qubits.
15:21
So what we need to do is we need to introduce some boundary. So we can use the segment of a plane with special boundary to encode one qubit. And you've seen this before, but one qubit isn't enough. So what we're going to do is we are punching holes into the code surface.
15:41
And I will explain on the next slide what that is. And then the way we handle the situation, a pair of holes will constitute a qubit. You see here already in this drawing, and you will see more of that, is the encoded Pauli operators. So one encoded Pauli operator, the encoded z here,
16:02
will encircle one of the holes, and the other Pauli operator will stretch between them. So let me define now in more detail what those holes are. So those holes are just missing stabilizers.
16:20
So stabilizers, as I said earlier, come in two kinds. Namely, we have side stabilizers and plaquette stabilizers. So what we call a primal hole is just a side stabilizer that's not enforced. So we're removing a generator from the stabilizer.
16:43
The stabilizer shrinks. Number of qubits stays the same. So this gives room to have, well, encoded qubits. Likewise for the plaquette operators. What we call a dual hole is just a missing plaquette
17:00
stabilizer. So we remove this plaquette operator from the stabilizer. And then, missing plaquette stabilizers, pairs of dual holes will support a dual qubit, and pairs of missing side stabilizers, that is pairs of primal holes, will support a primal qubit.
17:22
So let us now look at those qubits, those encoded qubits. So what you see here is two primal holes with their boundary. And now, the encoded z is a string that runs from one hole to the other,
17:41
whereas the encoded x is a string that loops around one of the holes. That was for the primal qubit. Now let's look at the dual qubit, ported by two dual holes. The x type string is running between the holes, and the z type string, the encoded z, is looping around one of the holes.
18:01
So when we look at those two pictures, we can infer the following rules. Namely, an x type chain cannot end in a primal hole, but it can end in a dual hole. The z type chain can end in primal holes, but it cannot end in the dual holes.
18:22
It has to loop around the dual holes. So these are the topological rules we have to respect here. And now we want to use them. Namely, I want to explain to you how a CNOT works for this code. So what you see here in this drawing
18:41
is just the code surface with the holes punched into it. So here we have two primal holes. That is the support for primal qubit. Here we have two dual holes, support for the dual qubit. And this acts as just time. So here, those holes are just moving parallel, so nothing happens. It's just storage.
19:02
OK, now we braid them, and we ask, OK, anything interesting happening here? And indeed, this configuration is suitable to realize a controlled NOT gate. And actually, this is something that I can show to you with what I have introduced.
19:22
OK, so that goes as follows. So let's consider this string here, this x type string running between two dual holes. OK, so let's go to our table that we discussed earlier. So we find, yeah, an x string running between two dual holes
19:41
is actually possible, and it represents an encoded x operator. So what we're now going to do with this thing is we slide it forward in time and see what happens. And to respect those rules, namely, the endpoints of that string must always remain attached to those dual holes and they can never end in a primal hole.
20:03
OK, so let's get going. You move this thing forward. Nothing much happens at the beginning, so the ends remain attached. But now, this primal hole starts coming in the way, and the string has to avoid it. So the string must recede and bulge out.
20:24
So now, by now, the primal hole has really come very much in the way, which means that this x type string now has to loop around it before it can end in the other dual hole. So finally, this loop here cuts off,
20:41
and at the end of the day, we are left with an x type string around a primal hole, I mean a closed loop, and a string in between the two dual holes. So now, we go back to our table up here and try to figure out what that is. So that, as it was before, is an x,
21:01
encoded x operator on the dual qubit, and this loop here is an x operator on the primal qubit. So we've seen that on the forward propagation, this operator has changed from a local operator to a two local operator, a non-local operator, and this is the signature for an entangling gate.
21:23
And in completely the same fashion, we can examine the other three Pauli operators, I mean the other x and the two z's, and we find those propagation relations in exactly the same way. And this tells us that we're dealing with a CNOT gate here.
21:44
And yeah. So we can now ask, what can we do here with this code in a topological manner? And it's not actually that much. It's certainly not universal. But what we can do is the CNOT, and I've shown you a simplified version of it a minute ago.
22:01
This one is a bit more complicated because you want to do a CNOT also between two qubits of the same kind. So the previous CNOT involved a dual and a primal qubit. You want to show that you can do a CNOT also between two qubits of the same kind. Well, anyway, we can do the CNOT. We can prepare and measure in the z eigenbasis,
22:24
and we can prepare and measure in the x eigenbasis. Yeah. But that's, as I just said, it's not universal, but it's at least a start. So how do you make this universal? So there is, in fact, only one additional operation that you need for universality here in this scheme.
22:42
And well, it is the preparation of this state that Andrew mentioned. It's the eigenstate of the operator sigma x plus sigma y. OK? And if you can provide the state with high quality, then we can run universal quantum computation.
23:02
In fact, there exists a procedure for doing precisely that, and this is magic state distillation. It's a protocol that breaks our topological construction, but we need to include it to achieve universality.
23:21
So this is one non-topological element in the construction. OK, so this is pretty much what I wanted to say about the gates. So let's get back to the thresholds. Let's now discuss the characteristics of the scheme. So let's begin with the thresholds. And so Andrew has already told you
23:42
that we can talk about an error threshold of various levels of detail. So let us surface code over here. And in fact, so the code, the thresholds for memory, they carry over as thresholds for fault-tolerant computation
24:01
with the code. So there is no deduction for the fact that you're actually computing, which is something that has to be shown, of course. But this is how it turns out. So the most elementary level at which you can provide a threshold is if you assume that your error correction is actually perfect.
24:22
Well, then if you assume that phase flip and spin flip errors are actually independent, then you arrive at the threshold here of about 11%. So the next thing that you can do is take into account the errors of syndrome measurement in a phenomenological fashion. Then your threshold goes down to about 3%.
24:43
But then if you really all split it up into gates and allow a gate error for each individual gate, your threshold goes down even more, but not that far. So what we end up with if we assume an error for each individual gate is a threshold of about a percent
25:01
now. This is a recent improvement of the threshold value. And this is not so bad. So let us compare this with other things. So first of all, I want to say, actually, you think this is now a region where you can actually begin
25:21
to meet with experiments. So you think that an error threshold of 1%, 1 in 100 gates failing, this is something that's probably within experimental reach. So you think it's probably scaling up systems is the much more difficult part here. But such accuracies should be in range.
25:42
Let me also compare this number with a number that I just learned this morning from Andrew. Namely, the threshold for classical fault-tolerant computation is 9%. Actually, I expected it to be a bit higher. But anyway, so we are not so far away from that number. And finally, let me compare this number of 1%
26:02
with the highest known threshold for fault-tolerant quantum computation. This is a result by Manik Nil, and without a geometric constraint. And that number is about 3%. So that number tells you, if you compare those two numbers,
26:21
is that the geometric constraint, which at the beginning seems fairly severe, actually doesn't constrain you too much. It's a factor of 3 that you are losing. So I think this is good news. So let's celebrate them before we go to the next slide, which will be about overhead.
26:42
Oh, actually, this is a slide about the error model. Well, I don't want to go into it in too great detail. We can talk about it if you have questions about it. This is basically what I said, that we have an error for each of the involved gates. And now comes the slide about the overhead. So this is perhaps a bit more mixed news.
27:03
So for the computer scientists, the operational overheads are polylogarithmic. So that doesn't sound too bad. For the experimentalists, especially if you sit in the back, this is 10 to the 7.
27:21
This is 10 to the 9, and so forth. So these are very, very big numbers. So let's see what's plotted here. So what we are plotting is the cost of an individual fault-tolerant quantum gate as a function of the total size of the circuit.
27:42
So say if I want to do 10 to the 8 logical gates, which I might, look here for the cost of an individual fault-tolerant quantum gate. So these numbers are indeed very, very big. But I should say one thing. Those curves are at the point where our base error rate is
28:04
1 third of the error threshold. So if our error rate is lower, then those curves will look better. So the scales will then change. So as I said, overhead is polylogarithmic. And what this means in practice is, the cost of a CNOT in a computation with 100 gates
28:26
isn't very much cheaper than the cost of a fault-tolerant CNOT gate if you have 10 to the 10 gates in the computation. So the increase is mild, but you're starting at a high level. That's a problem. So the red curve here was for the CNOT.
28:42
So the other curves, the green and the blue, they are for gates, the one-qubit gates that require magic state distillation in this protocol. So we see that they are higher. So the message is that, well, again, first for the computer scientists, the scaling is unaffected.
29:03
I mean, it remains polylogarithmic. The exponent remains the same. But in absolute terms, those procedures are very, very costly. So if we can get by without them, that would be a very good thing. So they drive up the overhead in absolute terms. And this is just a pi over 8 gate here.
29:23
So I leave it up to you to contemplate a Solovey-Kitaev construction on top of that. All right. So I have one more slide on this. So I want to get back to the point
29:40
that those curves might look a lot better if we go to lower error probabilities. But for this topological scheme, I didn't have a plot that would actually show it. Maybe somebody else at this conference will show such a plot later. Let me just discuss what I found in the literature.
30:00
So this is for nil scheme, the scheme with the highest threshold. And this is not topological at all. But he plotted in his paper the same figure, namely the cost of a C0 per the cost of an individual fault tolerant C0 as a function, this time,
30:23
of the base error probability and now for various computational sizes. Again, 10 to the 8 sounds something we might want to shoot for. OK, so here you see 3% is the threshold. So at 1 third of the threshold, you're getting something like 10 to the 11.
30:40
But if you are at 1 hundredth of a threshold, you're already down to 10 to the 3. 10 to the 3 is still a very big number, but it is a lot better than 10 to the 11. So I mean, I cannot guarantee that we will see the same kind of dramatic drops in our topological scheme,
31:01
but it is something to look for. So we need to do more analysis. OK, so with this comment, I want to leave the surface codes and want to move on to discuss another type of code, namely, Hector's topological color subsystem codes.
31:22
And as I said initially, the construction is rather spicy and has many interesting elements in it. And so before I want to put them all together, I want to discuss those elements separately in simpler settings.
31:41
OK, so the first element of Bohm-Bein's construction that I consider are twists. And we can discuss twists in the more familiar surface code. But we need to, or it's of advantage to look at the surface code in a slightly different way. So what we will be doing to the code
32:01
surface is two manipulations. First, on all qubits on horizontal edges, we will apply a Hadamard transformation and then rotate the code surface by 45 degrees. So we then end up with the letters. Oh, well, I come to that.
32:21
So this is the two changes that I'm making. And here you see the resulting operators that were the former Blaket operators and side operators. And they now look more similar to each other. In fact, they look exactly the same except for their location. So that is now a new lattice that we will be considering.
32:45
Now we're polar in it, just black and white for the moment. So what used to be the sides in the old lattice now becomes white plaquettes. And what used to be the old plaquettes will become dark plaquettes in this lattice.
33:02
So this coloring is what we now want to discuss. Likewise, what we inherit, of course, from the previous lattice are those closed string operators that give us an error syndrome.
33:22
So with the associated string operators, we can measure the error syndrome. So here you see a dark string. So this goes around what used to be a site. So dark strings measure the site type stabilizer.
33:43
Light strings measure the plaquette stabilizer. OK, so now let's take some stuff out of this picture again. And now let's take the color back out. Just remember that one of the faces was called dark.
34:03
And now we're going to do a modification to our lattice. And this will actually lead us to twists. So what we do, so the twists are analogous to what were the holes in the previous construction. The difference is that now a non-local manipulation
34:25
of the lattice is needed to introduce the twist. So we are cutting the lattice open and modify the edges along the cut. And the endpoint of that cut is what our twist is going to be.
34:40
So now after we have introduced that twist into the lattice, let's go back in. Ouch. Doesn't work anymore. So we fail to end up with a consistent coloring of that lattice. So we can still talk about a coloring locally,
35:01
but there is a global obstruction to the coloring now. Namely, along this cut here, we have neighboring faces with the same color, which is forbidden by our coloring. I just want to say one thing. So there's nothing physical about the location of the cut.
35:22
I mean, locally, the lattice looks perfectly fine. The obstruction to a coloring is a global property. So we can move this cut anywhere around here. The only property that we must require of the cut
35:42
is that it ends in the twist. OK. Now let's discuss those string-like operators again that go around in loops. So what we find now with the cut present,
36:00
that those string operators don't close anymore. So then we ask, oh, well, if they don't close anymore, what invariant meaning can we attach to their measurements? So that's a weird situation. Another property that we observe
36:20
is that the string operators, when going around a twist, change color. But this string does not correspond to anything that we would want to measure. So here is an operator that we can measure.
36:41
It has to go around the twice. OK. And so I leave the twists here for a while. But yeah, so the point is, the twists in this more elaborate construction will now take the role that the holes had earlier.
37:04
And we will get back to them. So much about the twists. And I now continue with subsystem codes. And I think I can be brief, because Todd already mentioned them this morning. But I would nonetheless refresh your memory about them.
37:25
And we introduced them by example. So maybe that's before we get abstract, let's start with an example. So those are stabilizer codes. So we need to define the stabilizer and the encoded Pauli operators. So this is what they look like. So again, we have a lattice here,
37:42
the qubits living on the sides, and the stabilizer operator z type, or just two columns of Pauli operator sigma z. And they could be anywhere. Likewise, the x type stabilizers are, or their generators, two rows of Pauli operator sigma x. The encoded Pauli operators are just
38:02
one column of individual Pauli operator sigma z, and one row encoded Pauli operator sigma x. And then, of course, it doesn't matter where you place that row or that column. Yeah. And now, if this was an ordinary stabilizer code, you would imagine that those stabilizer operators
38:23
is what's being measured to extract the syndrome. But that's not the case. Namely, what you measure are operators with very small support. And that's, in fact, the point of the whole construction. You get by with measuring two local operators.
38:42
So at first, you think, OK, I'm getting the idea, we're measuring those operators and their translates. And then, by classically post-processing the measurement outcomes, namely by multiplying them together, well, we can infer the outcome that we had obtained had we measured those stabilizer generators.
39:02
So far, so good. But then you notice, ouch, those operators don't commute. So what does that mean? So that doesn't look good. So if I measure an operator A and then measure an operator B that doesn't commute, am I not
39:22
losing the measurement outcome of the first measurement? Does this measurement outcome of the first measurement still make sense? Yeah, it seems a little bit of a peculiar situation. And actually, what really matters
39:41
is whether those operators commute with the encoded Pauli operators and with the stabilizers. And in fact, that they do. So yes, those operators are not necessarily commuting, but they will always commute with what we are interested in.
40:01
So while we are measuring them, we are not affecting those operators. So that's good about them. But if you're still worried, let's explain a little bit more. But that was just an example. Let us now become a little bit more abstract about those codes.
40:20
So here, in the case of these codes, there are a couple of types of operators that we would find a group theoretical framework for. So well, there is the stabilizer group as usual. And now, the operators that we measure in this scheme, they generate what's called the gauge group.
40:42
And that contains the stabilizer group as a subset. And then, there is the centralizer of the gauge group that is all those Pauli operators that commute with everything in the gauge group. And they will contain, in addition to the stabilizer, all the encoded Pauli operators.
41:02
So if you're still uncomfortable with the construction, then let me offer a bit of additional information here. And Todd already mentioned this. So yes, those operators are not commuting. And they mess up certain things in our code. So in addition to the system qubits
41:23
that we are interested in protecting, we have additional qubits, which we call gauge qubits. And when we measure those operators over here, we are affecting the gauge qubits, but not the qubits we are interested in. So why of this whole construction?
41:43
Well, there is a gain, and there is a loss. The gain is that we end up measuring operators that are very local. Non-local operators are hard to measure. So that's good about the construction. But there is a price to pay. And there are two ways of explaining it.
42:02
So for example, I mean, we are discarding the gauge qubits over here. I mean, those are qubits that could, in principle, be protected, but we choose not to protect them. So our rate goes down. Doesn't matter very much. But there is another way of expressing this. We could also say, well, alternatively, those gauge
42:21
qubits could be prepared in fixed states, say sigma z eigenstates. And then those, their encoded Pauli operators would turn into additional stabilizer. So by choosing to measure those very small operators, what we do is, in fact, we discard stabilizer.
42:41
As we choose to learn less information about our errors than we could have potentially have learned in this setting. And so we could potentially affect the error threshold for such codes. Yeah, this is what I wanted to say about subsystem codes. And now let me come to the final ingredient, the color.
43:02
So the standard setting to this color in codes is color codes, which are also an invention by Bambin and Martin Delgado. So what we are looking at here is a hexagonal lattice. And the qubits live on the vertices of that lattice. And the underlying lattice graph
43:22
has to be tri-valent for the construction to work. The stabilizers are associated with the faces of the lattice. And for every face, we have two types of operators, z-type and x-type. Okay, and again, we're dealing with a topological quantum code,
43:40
namely the number of encoded qubits that we can put in. A code surf without boundary is just four times the number of handles in that surface. And it's independent of the size of the surface. Okay, so this red and black is not why those codes are called color codes.
44:02
So now color comes into play. So what we can do here with those codes is to color the faces, such that no neighboring faces have the same color. And what color does for us, it is a convenient bookkeeping device. So as always in those topological quantum codes,
44:24
the operators that we are interested in, namely the stabilizer generators and the encoded Pauli operators correspond to strings. And now having colored the faces, we can color those string operators as well.
44:40
String operator that goes across the green faces and therefore we call it a green string. Likewise, this is a string operator that goes across the blue faces. And so we call it the blue string and so on and so forth. And as before, those string operators can be deformed without affecting the operator that they represent.
45:03
That's this rule over here. But now there's something in addition. And now you see why color becomes useful for those codes. Those strings can also splice up and then merge again and then continue as one string. So what we have here in addition, this is something that we didn't have in the surface code
45:22
is vertices where multiple strings can meet, where three strings can meet. But there is a constraint. Not every triple of strings can meet in a vertex. They must have different color. They must all have different color. And to take care of that,
45:41
you see that color becomes a useful bookkeeping device here. So let us now put all these ingredients together and let me review those topological color subsystem codes. Okay, so we begin with a hexagonal lattice,
46:03
pretty much the same as we had for the color code, but now differences are beginning to appear. So we have to place our qubits first. And this is done as follows. So for every site in the original lattice, we put three qubits here in this fashion.
46:24
So this is our location of qubits. And now this being subsystem codes, there are a number of questions to address. We need to ask, what is the gauge group? What is the stabilizer? What is the centralizer? Does the encoded Pauli operators?
46:42
Okay, so let's begin with the gauge group. So as in the case of the bake and shore code, the elements of the generators of the gauge group will be too local and they will be on those short links here, they will be operator sigma z, sigma z.
47:02
And on those long links here, they will be sigma y, sigma x. But there's only one such generator for each long link. So there's an orientation question involved here and you can figure it out from this little diagram here. So you have a y here and an x over here.
47:21
Likewise, for this edge, you have the y sitting here and the x sitting over here. Okay, so that was the gauge group. Next element, we need to talk about the centralizer, which will give us the stabilizer as a particular set, a subgroup, but also all the encoded operators.
47:44
So at this point, as a graphical device or bookkeeping device, we introduced the notion of a consistent shading, which is the following. Thank you.
48:02
Which is something like this. So we can introduce shadings for our Pauli operator separately. So the Pauli operator sigma z is only shading the edges in our decorated lattice. The identity shades nothing and the Pauli operator sigma x and sigma y, they shade edges and also corners of those faces.
48:25
And now a consistent shading is a shading where every triangular face here is consistently shaded. That is, it's either completely shaded or not shaded at all. And every such arrangement of consistent shadings,
48:42
well, I can, using this table, translate back into a Pauli operator and every such consistent shading will correspond to an element in the centralizer, will give us an encoded Pauli operator of our code, which could be the identity. Yeah, so this is a way of representing
49:00
the centralizer in that lattice. Now there is a level of abstraction or a clarification. We can translate every shading into a string net. So this is a one-to-one correspondence. And what we basically do is we relocate every qubit here to the next site,
49:22
which in this example is just here. And then, so that means all those edges are relocated and that gives us those strings and, or gives us a string net. And now the color of those strings is inherited from the color of those plaquettes over here.
49:41
So let me just, yeah, so let me see, can I, yeah, so for example, this string becomes this string and it inherits its color from this green plaquette over here. So if we are looking, let me see,
50:01
if we are looking at those two line elements, they become this green string. And why is it green? Because this line element and this line element, they become mapped to the same string segment and red plus blue gives green. Okay, just as a little bit of explanation
50:22
where this color comes in. Next thing we have to talk about as a subgroup of the centralizer, the stabilizer. Okay, so like in the conventional surface code, we have two stabilizers for each plaquette.
50:41
So there's a Z-type stabilizer, which looks like that. And then stabilizer generator involving X and Y poly operators, which looks a little bit more complicated. Okay, so that describes so far the subsystem aspects of this code. Now, where are the twists?
51:01
And what is a twist after all? A twist is a face with an odd number of edges around it. So what you can see here, whenever we have a twist in the lattice, this messes up our coloring scheme. So that corresponds with the twist that we saw earlier in the simple example of the surface code.
51:22
So as soon as we have twists, there's no longer a consistent coloring. And like before, we have cuts going out of the twist towards infinity. And along that cut, we have faces of same color meeting. Other thing is that for the twists,
51:40
there only remains one stabilizer generator and the other one is inconsistent. So the number of qubits doesn't change, number of stabilizer generators goes down, so we make room for encoded qubits. So far, my discussion was based on the shadings and let's now abstract a little bit more
52:02
and go from the shadings to the string nets. So here is what happens if you move a string around the twist. So let's do this in the example where the twist is of red color. So a red string doesn't change at all.
52:21
A green string is converted into a blue string and the blue string is converted into a green string. So when we have a string operator going around the twist, in general, the colors of the strings are permuted.
52:41
And now, let me finally come to explain where the encoded qubits are and how we do gates here in this fashion. And this will, now with a lot more preparation necessary, look very similar to what we saw earlier in the case of the surface code. So one example of getting encoded qubits here
53:00
is using four twists for one encoded qubit. And what you see here is the encoded Pauli operator sigma x and this string operator corresponds to the encoded Pauli operator sigma z. What I was not explaining earlier, so when strings cross
53:23
and you exchange the order of the operators, you get a plus sign if those strings are of the same color and a minus sign if the strings are of different color. So that's why those string operators reproduce the commutation relation that you expect for sigma z and sigma x.
53:43
Now, if you take two encoded qubits, each consisting of four twists of different color, you can perform an entangling gate in this following fashion. So fairly similar to what we saw in the simple example before, but this time it is the twists that are being moved,
54:03
not holes. So we take twist number three and four of the first qubit and take them on a journey and pass them through here between the second and the third twist of the second qubit and put them back into their original positions.
54:23
So this, it turns out, will perform an entangling gate for us. And we can analyze it in a very similar fashion to what we saw earlier. So under this deformation, the encoded z operator becomes this thing.
54:42
So then how can we manipulate the string over here? So this green string doesn't actually see those defects. So this defect is of importance only to blue and red string. So we can actually retract it and end up with a situation like this.
55:03
And now furthermore, we can introduce the stabilizer generator over here where the surface is perfectly fine and convert this situation to this situation. So now we can go back to our table up here and see that the z type operator
55:21
has been converted to what it was initially times an x type string operator on the second qubit. Again, the important point over here is that a local operator has been changed to a two local operator if we're referring to different qubits. And this is the signature of an entangling gate.
55:40
And if you, I mean, you can deal with the other Pauli operators in completely the same fashion, and you figure out that this is an x-controlled spin flip gate. So comparable to the CNOT gate. But how have we improved over the previous construction of the surface code? Well, it turns out that with this code,
56:01
we can now implement the entire Clifford group in a topological fashion. That doesn't make us universal, but we are better than what we were before. And we can therefore expect that this code will give us significantly lower overheads. I don't know.
56:21
I mean, I haven't done any simulation in this regard, but maybe we actually hear something about that here at this conference. So this is the material that I wanted to review today, and I hope I made you curious. Those constructions, so let me summarize. So, I mean, it gets even,
56:41
how many minutes have I left? Am I, oh, I think I'm, one minute. Okay, let me just close up. It gets wilder than this. So as Andrew already mentioned, there are the two RFV codes in which you can do the entire, that are universal by themselves.
57:01
You don't need any non-topological helper constructions, but they are not stabilizer codes. Probably more difficult to realize. Okay, let me just summarize. If you have a two local architecture and two dimensions, topological quantum codes are probably the best way
57:21
to go about this scenario. We are seeing very, very high threshold numbers. Overheads at this point wanna be reduced, and therefore, we are looking at quantum codes. But in principle, what the method that I've shown you
57:40
is of particular relevance, I would say, to arrays of Josephson junction qubits, but also called odd atoms in optical lattices, and to a lesser extent, also to segmented ion traps. Thank you very much for your attention.
58:01
Thank you. Any questions? Yes. Can you, sorry, can you repeat with your microphone? So the question was, how do I actually envision
58:22
those braiding operations? What would physically need to be done? And I mean, this is not topological quantum computation, so in our case, moving those holes or twists is actually a simple operation. So what you just need to do is a bunch of measurements. So we would be, say, I have no board here,
58:45
so what we would do at one side of the hole, say, let's talk about holes, you would do measurements that destroy the stabilizers, and on the other side of the hole, you would do stabilizer measurements to repair the code surface.
59:01
So it's a little bit like, I think snakes walk like that. So you're extending your hole on one side, repairing the surface at the other, and move the hole in this fashion. So this is by standard operations. This is all done by, in either case, both holes and twists.
59:20
This is all done by one and two qubit gates, so you need nothing in addition. Yes, Austin, I think that is?
59:46
OK, can I just, I think I just want to repeat the comment. The comment was that in the surface code states, you can still do the entire Clifford group without magic state distillation. That was the comment.
01:00:03
OK, thank you very much for that comment. Yes? In my talk here, the slides will be available online, but there is a circuit that will allow you to reuse the magic state for the escape over and over again. You need to distill it, but you just need to distill it once for the service code.
01:00:23
So that's a comment. Now I'll ask you a question, actually. The twist example that you gave, you had red being invariant and blue and green swapping to do your construction. Yes. There are some that allow red, green, and blue to be permuted among themselves as well, where red goes the cyclic permutation of all three of those.
01:00:40
Is there any advantage to that in making a better construction with twists if you use that kind of a twist defect? I don't know. I mean, I'm not sure. I think it's probably a better question for Hector. I mean, I was not claiming optimality here in any way. I mean, I'm not even sure that this four twists per cube
01:01:04
bit is optimal. So maybe you can do it with less. The main point I wanted to make about those codes is that you can do the entire Clifford group in a topological fashion.
01:01:20
So how much that buys you in the end in terms of overhead, I think, has to be analyzed in more detail. Hector, question. Abstract answer is that the twist that he was discussing are enough to generate
01:01:43
those more, you know, like these permutations that I mentioned, like they are combinations of these more elementary twists. That's why, I mean, you don't need to, I mean, they are already, yeah, yeah, thank you. Okay, thank you again.
01:02:04
Now we'll continue our tutorials with Daniel Ledor. We'll talk about dynamical decoupling.