Bulk fault-tolerant quantum information processing with boundary addressability
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/35293 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
12
23
24
29
31
37
38
00:00
Process (computing)InformationThermodynamisches SystemQuantum computerQuantum information scienceSelf-organizationFault-tolerant systemMereologyThermodynamisches SystemAddress spaceLecture/Conference
00:47
Thermodynamisches SystemThresholding (image processing)UsabilityData recoveryQuantum computerPlanningFault-tolerant systemFehlererkennungData recoveryAddress spaceMeasurementComputer architectureRevision controlQuantum computerClassical physicsFeedbackError messageComputer animation
02:30
Digital electronicsType theoryComputer architectureArchitectureGame controllerDifferent (Kate Ryan album)QubitBusiness modelQuantum computerComputer animation
03:08
Control flowChainQuantum computerQuantum computerGame controllerQubitTerm (mathematics)Real numberLevel (video gaming)Type theoryCellular automatonComputer animation
03:49
Rule of inferenceType theoryQuantum computerMultiplication signType theoryNumbering schemeChainQubitRule of inferenceSequenceQuantum computerPulse (signal processing)Numbering schemeGame controllerLengthExecution unitAlgorithmPattern languageComputer programmingRight angleUniverse (mathematics)Identity managementGreen's functionBitMereologySpeciesSatellite1 (number)Game theoryQuicksortGraph coloringInstance (computer science)Array data structureComputerComputer animation
05:55
Numbering schemeControl flowSimilarity (geometry)Numbering schemeError messageQuantum computerMeasurementUniverse (mathematics)Game controllerQubitVideo gameResultantGame theoryCellular automatonComputerSocial classFehlererkennungPropagatorComputer animation
06:53
WebsiteNumbering schemeControl flowSimilarity (geometry)ArchitectureThresholding (image processing)ChainMaxima and minimaRegular graphPole (complex analysis)SequenceLinearizationDifferent (Kate Ryan album)State of matterSpeciesFraktalgeometrieOperator (mathematics)Data structureUniverse (mathematics)Phase transitionFlow separationArray data structureMultiplication signCASE <Informatik>ChainPulse (signal processing)Cubic graphPattern languageNumbering scheme1 (number)Key (cryptography)Instance (computer science)Thresholding (image processing)QubitNumbering schemeComputer architectureHadamard matrixQuantum computerFocus (optics)Perfect groupIsing-ModellComputer animation
09:10
Execution unitError messagePulse (signal processing)Hadamard matrixRotationPlanningPosition operatorDirection (geometry)Address spacePhase transitionFault-tolerant systemSlide ruleError messageThermodynamisches SystemUnitäre GruppePulse (signal processing)Revision controlType theoryGreatest elementQuantum computerHarmonic oscillatorCorrespondence (mathematics)FrequencyChainNumbering schemeState of matterFehlererkennungComputer animation
10:57
Quantum computerType theoryQubitNumbering schemeControl flowThresholding (image processing)Convex hullPulse (signal processing)Error messagePlane (geometry)Thermodynamisches SystemAxiom of choiceMeasurementHill differential equationNumbering schemeChainUniverse (mathematics)Correspondence (mathematics)Exterior algebraPhase transitionGame theoryQuantum computerThermodynamisches SystemPlanningError messageGame controllerFehlererkennungData recoveryUnitäre GruppeMeasurementInterior (topology)Programming paradigmCodeThresholding (image processing)AreaPulse (signal processing)Line (geometry)Multiplication signRootDifferent (Kate Ryan album)Greatest elementSingle-precision floating-point formatComputer animation
12:58
Error messageOperations researchReal numberInformation managementQuantum computerMeasurementBinary multiplierError messageLine (geometry)AreaFehlererkennungState of matterComputer animation
13:31
Error messageThresholding (image processing)Operations researchDigital electronicsError messageScaling (geometry)Business modelCodeData managementThresholding (image processing)Computer animation
14:04
PiMeasurementCodeFehlererkennungQubitMoment (mathematics)Perfect groupComputer animation
14:58
MeasurementError messageUnitäre GruppeThresholding (image processing)Dynamical systemError messageBit rateMeasurementMultiplication signUnitäre GruppeRevision controlDigital electronicsOperator (mathematics)FehlererkennungType theoryHydraulic jumpData recoveryBitQubitCodierung <Programmierung>Computer animation
16:23
Quantum computerCodeData recoveryCodeBitQuantum computerFehlererkennung2 (number)CollisionQubitVotingDigital electronicsComputer animation
17:09
CodeQuantum computerIRIS-TState of matterSingle-precision floating-point formatSet (mathematics)QubitError messageBitComputer animation
17:35
CodeCodierung <Programmierung>Error messageOperator (mathematics)Transverse waveMultiplication signRight angleBitElectronic program guideFehlererkennungDirection (geometry)Pattern languageCodeState of matterMeasurementLevel (video gaming)Degrees of freedom (physics and chemistry)Computer animation
19:14
Queue (abstract data type)BitCoroutineLevel (video gaming)CuboidDuality (mathematics)TrailError messageGraph coloringFault-tolerant systemProcess (computing)FehlererkennungMereologyNumbering schemeCodeQuantum computerComputer animation
20:21
Type theoryMereologyGauge theoryFault-tolerant systemUnitäre GruppeGame controllerError messageBlock (periodic table)CodeCodeLevel (video gaming)Set (mathematics)Degrees of freedom (physics and chemistry)Row (database)VotingComputer clusterPattern languageFehlererkennungCodierung <Programmierung>Multiplication signDegree (graph theory)Power (physics)Queue (abstract data type)Student's t-testRight angleCartesian coordinate systemNumbering schemeTheoryData recoveryComputer animation
23:13
State of matterKälteerzeugungThermodynamisches SystemPlanningInformationComputer engineeringQuantum information scienceComputer animation
23:55
Execution unitRoundingFault-tolerant systemPerfect groupNumbering schemeState of matterVotingQR codeInstance (computer science)Physical systemGoodness of fitQubitComputer animation
24:48
Clifford algebraThermodynamisches SystemLogicEmailLevel (video gaming)Operator (mathematics)Digital electronicsPerfect groupInstance (computer science)Thermodynamisches SystemQuantum computerState of matterFault-tolerant systemCloningRevision controlBootstrap aggregatingPivot elementMeasurementComputer animation
26:09
Basis <Mathematik>Error messageThresholding (image processing)Module (mathematics)MeasurementRoundness (object)MeasurementThresholding (image processing)Type theoryError messageNumbering schemeBitPhysicalismBit rateDegree (graph theory)Different (Kate Ryan album)Level (video gaming)Observational errorWebsitePower (physics)Parameter (computer programming)Video gameModule (mathematics)Instance (computer science)Computer animation
27:45
Chi-squared distributionComputerImplicit function theoremPulse (signal processing)Different (Kate Ryan album)Phase transitionDegree (graph theory)RotationBitComputer architectureError messageType theoryCross-correlationHadamard matrixPlane (geometry)Direction (geometry)PlanningBusiness modelCodeRoutingMereologyInstance (computer science)Computer animation
28:41
Numbering schemeLogicMultiplication signControl engineeringAddress spaceNumbering schemeQubitOperator (mathematics)BitQuantum computerMeasurementData recoveryIntegerDigital electronicsComputer architectureInternet der DingeSlide ruleComputerDivisorComputer animation
29:35
QuiltExecution unitError messageRhombusUnitäre GruppeData recoveryNumbering schemeMeasurementMultiplication signNetwork topologyThermodynamisches SystemInformationGame controllerObservational errorCodeType theoryThresholding (image processing)Planar graphImplementationGoodness of fitControl engineeringTwo-dimensional spaceRight angleOrder (biology)Address spaceMedical imagingCone penetration testOrder of magnitudeCodeTheoryCASE <Informatik>Film editingMultiplicationRevision controlCodierung <Programmierung>BackupLine (geometry)Lecture/Conference
Transcript: English(auto-generated)
00:22
Well, thanks very much. My name is Jason Twombly. Thanks very much to the organizers for allowing me to tell you about some of this work. So I'll be talking about, as it says there, bulk fault tolerant quantum information processing with boundary addressability. And it has quite a lot of relevance with the last talk
00:40
as well. So that's pretty handy. So I'm from Macquarie University in Sydney. And where's that? There we go. Yes. So it's in the city of Sydney. We do have kangaroos on campus. That beach is not actually on the campus, but it's actually on a place on the island.
01:01
Lots of kangaroos on Kangaroo Island. Unfortunately, it's not close to Sydney. OK. So what I'll be talking about, the plan, is that the question I've been asking myself for the last few years is, do we
01:21
need complete addressability when we build our quantum devices? And obviously, since I'm here, the answer is no. But then the question is, how can we form a quantum error correction if we don't have complete addressability? And in more particular, how can we do fault tolerant quantum
01:40
error correction? And if we don't have addressability, then we have to perhaps give up the idea of making addressable measurements and classical feedback and correction. So we'll be talking a lot about coherent recovery. So and then we'll talk about error correction with coherent recovery.
02:01
That relates to the last talk. And then how to make that fault tolerant. And then we'll try and motivate, OK, it's a three-dimensional, but we can also give you a two-dimensional version of a semi-global architecture that uses very little addressability, which is fault tolerant and can essentially act as a quantum fault tolerant
02:23
transport, quantum wire, or full-blown quantum computing. So this is just to motivate, as we go to very large devices, do we actually need to control every single thing in the actual device?
02:42
And there's many different ways of, this was talked about on Monday, different types of architectures for quantum computing. The main one I'll talk about is the circuit-based model. But it'd be quite interesting to see if the ideas we present here can be generalized to the other types of architectures. And so do we need to have control
03:01
over each and every single qubit? And obviously, the answer is no, or else I wouldn't be here. And why that is technologically very handy is that as you go to fairly complicated designs, the control technology you'd need to do to actually address and control each and every qubit
03:23
will get very complicated and consume a lot of real estate on the chip or whatever. And so any type of idea to reduce the level of control would be good. And what we're going to do is we're going to borrow a lot of ideas from cellular automata. And this is known now in the literature in terms
03:43
of quantum control as global quantum control. So this topic of global quantum control started a long time ago, actually. So Seth Lloyd published in 1993 an idea for a universal quantum computer that
04:01
was based on a spin chain, Heisenberg coupled spin chain. We only had three distinct species, A and B and C. And they were coupled in a 1D chain in this alternating pattern. And he showed how essentially you could essentially put in a quantum algorithm and program up that spin chain to do whatever you liked.
04:21
Then a bit later, Simon Benjamin, who's in the audience, had a very nice scheme where, again, you had an alternating spin chain, but this time there's only two species, A, B, A, B, A, B. And you fed in distinct types of patterns of qubits. One type of pattern, data qubits, moved to the right under certain sequence of pulses.
04:41
And these were global pulses on all of the either A or the B type spins and other pulses and other types of patterns called a control pattern, which moved around independently of the green data bits. And it could affect gates at certain times under other types that came in.
05:01
So the basic rules are if you're not allowed to have an individual addressing or readout of an individual qubits at will, you can have spatially structured arrays, as you can see here, A, B, C, A, B. But you can address and read out banks of identical qubits.
05:21
So it turns out there's essentially two types of schemes that have been discovered so far. One is this scheme here, for instance, that has data patterns that move around and control units that move around that essentially localize these global pulses to produce local gates. Another one that have been discovered
05:42
is one Robert Rausenorff, and as well Joe Fitzsimons and myself found schemes that used essentially the finite length of the chain to produce gates. So there's not many experiments. Mostly these are NMR, quantum computing.
06:00
Here's some results from an experiment done by Jonathan Jones and Joe Fitzsimons and others, three qubit experiment. But there's plenty of ideas. This is David Corey and Raela Mike Mosca. This is to amplify using quantum cellular automata, a measurement result. Here's a crystal of dipolar molecules
06:22
from Peter Zoeller, where perhaps, although he doesn't look at this, one could also do global control here. And here's a recent work by Thomas O'Colarco and others on perhaps doing some quantum games of life.
06:41
So OK, so people have now built schemes which, going back to these, are going back here, they're capable of doing full-blown universal quantum computing. But how about error correction? So we would like, for instance, to have at least something,
07:00
for instance, like a perfect quantum channel, which is fault-tolerant, or universal quantum computing, which is fault-tolerant. And can it be done? Well, myself and Joe Fitzsimons presented at the last conference several years ago here a scheme which was a bit difficult. Here we had a self-similar, almost fractal-like structure
07:22
of qubits, different species, and the actual threshold was very small. So it seems pretty hard. But if it was possible, if the thresholds were much higher, it would be much nicer. So what I'm going to do is focus on this particular architecture.
07:40
This is this scheme, again, where we have a sequence of linear array of qubits that are coupled, say, by Ising. And one applies these red and blue pulses. These are homogeneous pulses of either C phase, the red, or, sorry, X, yeah, that's right, C phase gate.
08:02
And the blue are the Hadamard pulses on each individual qubit. So one could show that, for instance, if you start with an X gate on that spin, it moves to X gate here and to Z gates on neighboring ones. And this whole pattern, this whole qubit pattern, delocalizes over the whole spin chain.
08:20
But if you repeat the pulses a number of times, then this particular gate here recoheres on the spatial opposite side of the chain. And indeed, if you have a look, if you repeat this particular homogeneous pulse of Hadamards and then C phase gates, n plus 1 times,
08:41
where n is the number of qubits in the chain, then the whole spatial array is mirrored. And this is independent of the initial state of the chain. So this is sometimes known as a mirror operation. And essentially, if you had a particular state on one chain initially, it would be perfectly transported to the other end of the chain at the end of this mirroring,
09:02
irrespective of the state of all the other qubits in the chain. So that's pretty handy. And it also works for CV systems. So here's some work we did. Here now, the C phases now are replaced by this type of unitary.
09:21
It's just a position of the two harmonic oscillators coupled to each other. And the Hadamards are just half of rotation of the harmonic oscillators, quarter of the rotation. Essentially, we have a three CV system in some initial state and after this mirroring, it's flipped.
09:44
So the idea we had was to take this type of scheme, where you have n spins in a chain, and to replace each spin by a plane. And so essentially, this is a 3D version of this quantum wire. And each plane will essentially undergo fault-tolerant quantum
10:03
error correction. These global pulses are now replaced by C phases, which act down vertically here. And Hadamards act on each plane individually. So it's not completely global, as I've indicated here.
10:23
Maybe on the next slide. It's not completely global. We're going to have addressability in this xy direction. So this is the xy direction. But everything is uniform in the z direction. Later on, we'll need to be able to address each alternate plane.
10:41
So we will have to keep this AB addressability in the different planes. Each plane essentially holds one encoded qubit, corresponds to that spin in the spin chain. And the top and bottom are football. So this goes back to, I didn't mention it,
11:00
but in this scheme, I mentioned here how these alternative Hadamard and C phase pulses mirror everything. If you add to this particular scheme the ability to do non-Clifford gates at the end of this chain, then you can do universal quantum computing on this chain. So that corresponds to being able to do non-Clifford
11:21
gates on the boundaries. Boundary planes here are the top and bottom planes. And the nice thing about this is if we have an error in this global pulse, then essentially it won't lead to correlated errors in a single plane.
11:42
Different planes will have errors. So our restriction now for this semi-global paradigm is that we're not going to allow ourselves to do any measurement or control inside the bulk interior planes of this device.
12:01
And we have to recover coherently from our errors without measurement, essentially coherent recovery. And we call that unitary quantum error correction. So we're going to choose a code, a quantum error correction code, and that'll be the vacant short code. And eventually we'll show you the thresholds that we found.
12:21
Oh, here they are. So the gate threshold that we found is about 10 to the minus 5. And the preparation, so we do need to reset qubits, obviously, to pull out the entropy. The preparation and the measurement, which we only have to do at certain times, is pretty high.
12:43
So the actual refresh engines inside this device can be pretty bad. And this holographic control, essentially all we're doing, most of the control essentially is at the top and bottom planes. So essentially, talking about quantum error correction,
13:04
we've heard a lot about this. We need to be able to prepare states. We need to be able to do gates. We need to measure. And what we're going to have, we're going to characterize the probability for errors both in the preparation, that is, being able to build cold ancilla to take away the entropy, the actual gates, the unitary gates
13:22
that we have to do, and eventually the measurement. And we have to make sure that errors don't multiply. So of course, this goes back to the previous talk. Essentially, the idea is we're going to redundant coding, and we're
13:40
going to concatenate. And we're going to try and make sure everything is transversal as much as possible. And I guess we know that if we make everything fault tolerant, then eventually, if we get a physical error below a certain, we can scale up as much as we like. So the thresholds, however, depends on many things, the code, the design, and the error model.
14:03
Many things. But measurement is a real pain, and I found this. It's a jigsaw, a pretty big jigsaw here. So essentially, you can just figure out that if you just have a moderately sized, I guess, well, I suppose at the moment it's not.
14:21
It's huge. 100 logical qubits, 9 qubit baking short code. Then essentially, you'll have about 10 to the 6 physical qubits. And you'll be doing something like 10 to the 4 measurements at every error correction step. So we want to try and avoid that.
14:41
And of course, measurements even now, OK, the best measurements are in ion traps. But measurements aren't perfect. And so trying to remove as much as possible the need to do measurements is technologically much better.
15:02
So some things we're not going to assume. We're not going to assume that all these error rates are the same. We can assume that measurements take a long time. And unitary gates can be improved by dynamic coupling, as we've heard. OK, so now what we want to do is somehow
15:28
to remove measurement from the error correction syndrome. So we saw this type of circuit a few times in the last few days, where this is the 3-qubit bit flip circuit, where you encode,
15:41
you have an error, you decode, and you do the recovery. And then you hopefully try to reset and repeat. Unfortunately, when you do the recovery, the decode it. But of course, we've heard now that one can measure the syndromes, add a few more qubits, essentially measure
16:02
the syndromes, and do the recovery. And this was nicely done in the last talk through jump operators. However, essentially, a unitary version of this would be this three Toffli gates here. And then you would have to reset these two ancillas here.
16:24
So what we're going to do is we're going to look at the Bacon-Shore code. And what's going to be very useful for us is something called a majority voting gate. And the Bacon-Shore code is a, well, here's the bacon. But essentially, I'll show you this later in a minute.
16:40
But here's the three-qubit code. And this is what our majority voting gadget will look like. And I'll explain this in a few seconds. But coherent recovery is pretty essential for most of the current experimental efforts. We'll hear about this later on this week. The trapped lions, the NMR, and the superconducting
17:03
quantum error corrections all used coherent recovery. So what I'll talk about a little bit is this majority voting gate, which essentially repairs the single-qubit error in this encoded state.
17:24
And I'll step through this bit by bit just to show you how this works. Essentially, if you imagine that the first bit has flipped, and we have two banks of three ancilla, so here and here, then the first gate, the first two gates here,
17:42
this is just a Control-X. And this is a Control-X where the target is shifted to the right. So that's that one there. And you notice that this here, that this is a Control-X. That is also shifted. But that flips that back to zero. And that one is cyclic and shifted to the right. So then you have this state.
18:00
And then finally, we have this Control-X, but it's in the other direction. And so essentially, this is controlled off this middle bank of three. And essentially, you end up with this pattern. And then finally, you do this bitwise-toply to the top. And if you notice now, the bitwise-toply to the top will correct that guy to zero and correct that guy to one.
18:22
And now you're back into a product state. And this is now being corrected. And now you'll have to refresh these guys. But the interesting thing here is that essentially, OK, I'll leave that. OK, so we'll use a bacon shortcode. We've seen that many times.
18:41
These are the stabilizers. These are the logical operators. And we've talked about this subsystem code. There's gauge degrees of freedom as well. The nice code is many of the operators that we need to do the mirroring and the error correction are transversal. The only one that's not transversal is this z-half,
19:02
which we won't actually need too much. And only now and then, at the very end, we'll have to do measurements at the very highest concatenation level. So here is the actual error correction
19:21
routine for the fault-tolerant error correction at the k-th concatenation level. So this is very similar to what I had before. And this is the one now adapted for the bacon shortcode. And what I'll do is I'll step through this step bit by bit to show you how it works. Essentially, it works by using the bacon shortcode
19:44
and extracting the syndromes, again, into the bacon shortcode, but processing them in a QR repetition code, and then correcting them back into the bacon shortcode via the quantum repetition code. So essentially, here's the actual data.
20:00
And we need some ancilla, which I'll show you in a minute how we prepare. And essentially, this part of the scheme corrects for x errors. And this part of the scheme is the dual. It corrects for z errors. And so, OK. So the first box, OK.
20:23
So what I'll do is I'll just make a little cartoon here. This is the data. This is the ancilla. This is a k plus 1 concatenation. This is 9 at k. And this is just a copy of the last row just to show you what's happening. These are all in the bacon short encoding, and this is in the QR encoding down here.
20:43
So let's imagine that we start, and there's an error that happens to be here, an x error. Then the first part of this block that we had in this majority voting type correction scheme, the first part is to do this x copy
21:00
and also rotated x copy down. That gives you this into the bacon short ancilla. Then what we do is we start. We move on to the first part of this. This just copies, just control x's everything into the last column, which I've just separated out here from clarity.
21:22
And the second part then converts it down into a QR encoding. So this now, you have a very large QR encoding, and essentially we have that type of a code.
21:41
This last part of that majority voting essentially does this control x now, again, but rotating backwards. So this just moves down like that. And now finally, we do this bitwise toffly, which can work. These are now classical data, essentially.
22:03
And we just go back and move up and flip the columns in the bacon short code. And that produces an x for this particular set of syndromes. And that's now two x's there. It's just a gauge degree of freedom, so it's no longer in error. If we had started with two x's as an error,
22:23
that's just a gauge degree of freedom. And you see what happens now. When we copy this down using these two parts here, the cx and the rotated cx, you get this pattern appearing in the ancilla. And then when you control x, move that over. Oh, well, I've done it already.
22:41
Those cancel out. Two x's, they cancel out. And essentially, these are the codes that you have in the QR syndromes. And that's correct, because that's just a gauge of freedom anyway. So that was the fault-tolerant unitary error recovery done
23:04
at any concatenation level. So how do we get the fresh qubits? Because we need to withdraw entropy all the time. And so this is our picture of how the whole thing works. We have to have, scattered within each plane,
23:20
there are many, many systems which can be reinitialized, perhaps not very well. That's your refrigerator. Then we'll have methods to purify them. And then send these cold ancilla over to our computational engine. And that can do Clifford, Clifford gates.
23:40
Then, of course, it can send things off here to do magic state preparation. And once we have cold magic states, we will block the quantum information process. Now, if I don't want to do this, then just this alone
24:00
is this fault-tolerant perfect transport channel. So one way of preparing cold qubits is we'll have to have some physical systems that we'll be able to reinitialize. So for instance, if we have NVs, we can optically pump them to initialize their initial state. And it might not be very, very good initialization,
24:22
but as Ray LaFlamme mentioned yesterday, you can use a few rounds of algorithmic cooling to get extremely cold initial states. We can use this majority voting gate in a number of ways to prepare the ancilla.
24:40
And so here's a preparing logical ancilla for the vacant shore and just physical ancilla for the QR codes. And so that essentially does this perfect fault-tolerant quantum transport. So to do the magic state, we have to do non-Clifford operations on the boundary.
25:02
And essentially, we'll do those at the highest level of concatenation. And we've heard this before, both Monday and Tuesday. Essentially, what we have to do, we do distillation. We make many fairly initially bad states and we bootstrap them up to a not-so-good
25:24
logical magic state. And so essentially, this is what we do is we take an inner state, we encode it into a larger version, and if these gates are good enough, then it's almost, it has to be
25:41
within a certain fidelity of a magic state. And then once we get it there, we can just use distillation once our gates are good enough to get to a magic state. And then once we get to this magic state, for instance here, this is teleportation into the circuit to get a non-Clifford gate. And we only have to do this
26:01
at the highest concatenation level, and we do it on the boundary. And this, we do need measurement, but it's at the highest concatenation level. So when we go through and work out the thresholds, so we're going to work out the thresholds for preparation. That's initializing these entropy-reducing sites,
26:26
and measurement, and also the gates. We find, we work through all the different types of air modules, and essentially, this one has the highest air rate, and we count the number of malignant pairs. That's what we did,
26:41
and we find for this type of value for the threshold, which is actually pretty commensurate with what the measurement has. And so our physical error rates for gates has to be lower than this threshold. Now, the measurements at the highest concatenation level
27:01
essentially can be very bad, but essentially this depends on how good our preparation is. And so if we have very good gates, then our algorithmic cooling can work very well, and in very few rounds can produce very cold ancilla, and so our measurement threshold can be very high.
27:24
And so there's a bit of a degree of flexibility here. So for instance, if our physical gate threshold, our physical gate error rate is much below this, then we can get our preparation error up to 1%, so that, because, and essentially our measurement error
27:41
then can be very high. So what we've shown now is we've gotten this type of 3D architecture. We have semi-global pulses, take global pulses in this direction, but addressing in the XY direction. The planes need to be A, B addressable,
28:01
and that's because, for instance, when I do a Hadamard on a plane, in the vacant shore code, it flips, it corresponds to a rotation by 90 degrees. And also, if I do the C phase gate all at once, there is a possibility of having correlated errors across different planes, and so we do it in two parts.
28:20
Now, if it is possible, through a bit of work, to push this into a 2D arrangement, but for that to be true, we need to have non-nearest neighbor gates, which might not be so easy in various architectures. So essentially, that gives us a fault-tolerant swap to move things around.
28:42
So the whole idea was to see if we can reduce the number of controls that we needed to do various operations in this quantum computer, and so we estimate now how many gates and qubits we need to do, say, for shore factorization, with these number of integers of these number of bits.
29:01
And what we do is we compare, these are the number of logical bits, and this is the improvement that this particular architecture has against an addressable circuit, but that uses unitary recovery. And this is with an addressable circuit
29:20
with traditional measurement recovery. And so there's some savings, significant savings here. So this is eight times better, 86 times better, 2,000 times better, 4,000 times better. Okay, so this is my last slide. Am I, okay, good.
29:42
So what I've shown here is a semi-global method, where we have the controls on the boundaries, measurements on the boundaries, and we call that holographic. Everything in the bulk is essentially happening,
30:01
essentially globally. There's unitary recovery and entropy dumping happening all the time within the bulk of this device. We've got 2D and 3D designs, and the thresholds that we've gotten seem to be on par with measurement-based big chore. So one thing that we could look at in the future,
30:22
although this seems pretty difficult, can we devise new designs which are more global and find fairly more decent thresholds for them? So the design that Joe Fitzsimons and I found a few years ago had a very, very bad threshold. But maybe one could perhaps look at other types of codes,
30:43
planar codes, topological codes, and devise coherent recovery schemes for them, and they might have much better thresholds. Okay, thanks very much. Thank you very much, Jason.
31:01
I trust there are questions. There's one over there. I'm trying to figure out where you would prefer to use these gadgets rather than measurement. Because if you've got essentially
31:21
two-dimensional addressability, then you can do two-dimensional codes, planar codes, topological codes. So it seems that what you're doing is replacing every measurement with a multi-cubic gait. And it seems that you therefore require a system
31:42
where the errors on multi-cubic gait are very much less than measurement errors. Now, I'm a theorist, so I don't particularly know many experimental systems, but that seems to me counterintuitive. Can you perhaps say which systems that's true
32:02
or whether that's not necessarily the case? So the whole motivation behind this is, as Hadiya was mentioning, I don't want to bring the measurement information back up to the classical world and then do a classical control back down onto the device.
32:20
That requires an awful lot of technology. If I have a large chip with many, many qubits, I have to then bring classical, beside them I would have to have measurement devices buried everywhere, and all that signal would have to come up to a classical computer out of the Dewar or out of the cavity array
32:41
and be processed, and then a whole bunch of control technologies going back down, redoing the recovery. So that's what I'm trying to do away with, all that layer of technology. May I just comment on that too? Because especially for trapped ions or other systems that are related to that, measurements are expensive. They take a long time and they slow you down
33:02
by orders of magnitude, and also they introduce errors that are completely unwanted. So I think this is the right approach and I'm going to talk about that in more detail. I think that is very much depending on the implementation. I just wanted to clarify something.
33:22
When you're doing your algorithmic cooling in the bulk, I mean, clearly not everything in the bulk is unitary or? No, no, that's right. So scattered throughout the bulk, there'll have to be these little coolers. So there's little nano diamonds scattered throughout the bulk, which I can optically reset.
33:42
But we've shown that they don't have to be very upset. Is there another question? If that is not the case, thanks again very much Jason. And we come to the.