Design and analysis of autonomous quantum memories based on coherent feedback control
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/35297 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
12
23
24
29
31
37
38
00:00
Semiconductor memoryControl flowQuantumMathematical analysisContinuous functionMathematical modelQuantumBitMathematical modelSelf-organizationControl theoryOcean currentFeedbackDigital electronicsGroup theoryHamiltonian (quantum mechanics)Type theoryControl flowLattice (group)View (database)Formal languageQuicksortSemiconductor memoryCASE <Informatik>VorwärtsfehlerkorrekturObservational studyStandard deviationFormal grammarReal-time operating systemConnected spaceDynamical systemMathematical analysisAutonomic computingSoftware developerOrder (biology)Level (video gaming)Address spacePhysicalismMultiplication signConnectivity (graph theory)Term (mathematics)Sinc functionPhysical systemStack (abstract data type)BuildingInteractive televisionClassical physicsInformationUnitäre GruppeQuantum information scienceStability theoryNeuroinformatikProcess (computing)Experimental physicsPoint (geometry)FehlererkennungKey (cryptography)MeasurementModal logicMathematical modelNoise (electronics)Set (mathematics)Error detection and correctionAnalogyUniverse (mathematics)Form (programming)Row (database)Error messageTranslation (relic)Film editingoutputMappingFunction (mathematics)Computer animation
04:19
Scale (map)Solid geometryNeuroinformatikForm (programming)Power (physics)Classical physicsState of matterInformationNonvolatile BIOS memoryScaling (geometry)Digital electronicsHybrid computerLevel (video gaming)FehlererkennungSingle-precision floating-point formatQuantum information scienceProgramming paradigmImage resolutionSlide ruleFocus (optics)Einbettung <Mathematik>QuicksortDissipationProcess (computing)QuantumPhysicalismMathematical modelRevision controlPhysical systemQuantum computerBefehlsprozessorFlash memoryGroup actionMultiplication signUniverse (mathematics)OpticsComputer animation
06:20
Error messageDigital electronicsQuantumConnectivity (graph theory)Slide ruleData storage deviceSequenceQuicksortOcean currentComplex analysisWeb 2.0Limit (category theory)Projective planeDigital electronicsDigital photographyPlanningINTEGRALSolid geometryView (database)Theory of relativityOrder (biology)Function (mathematics)SynchronizationProgramming paradigmFunktionalanalysisComputer scienceFehlererkennungDiagramQuantumAnalogySimilarity (geometry)Medical imagingoutputState of matterDigital signalOpticsError messagePrimitive (album)Power (physics)Positional notation1 (number)Multiplication signGraphics tabletOperational amplifierPeripheralDifferent (Kate Ryan album)Elementary arithmeticBitAlgorithmContrast (vision)MappingMagnetic stripe cardSpacetimeControl flowElectronic program guideSoftwareNetwork topologyWaveData structureVorwärtsfehlerkorrekturWeb pageForm (programming)Ewe languageWritingWordGreatest elementMembrane keyboardSeries (mathematics)Cartesian coordinate systemQuantum circuitComputer animation
11:00
Continuous functionMathematical modelMeasurementMaxima and minimaConvex hullResultantFrequencyPhase transitionSpacetimeMatter waveDistanceReflection (mathematics)Complex numberResonatorBoundary value problemFehlererkennungIntegerLaserCharge carrierQubitCASE <Informatik>InformationOrder (biology)Sigma-algebraDiscrete groupObject (grammar)Stability theoryGroup actionAtomic numberData structureParity (mathematics)Error messageDigital electronicsVorwärtsfehlerkorrekturDiagramSuperposition principleFood energyArithmetic meanLevel (video gaming)QuantumControl flowComplex analysisZeno of EleaParadoxOrder of magnitudeVacuumBitPower (physics)Asynchronous Transfer ModeMultiplication signQuicksortPhysicalismExterior algebraOpticsNumberRevision controlMeasurementDifferent (Kate Ryan album)Similarity (geometry)Positional notationTerm (mathematics)Sound effectType theorySingle-precision floating-point formatLogicQuantum entanglementCubeScatteringFile archiverState of matterRight angleAlpha (investment)Ideal (ethics)Physical lawResonanceHeegaard splittingShift operatorSource codeFisher's exact testPiCubic graphPhysical systemGame theoryProteinCore dumpApproximationComputer animation
17:08
Continuous functionMeasurementMathematical modelSequenceParity (mathematics)ScatteringMaxima and minimaConvex hullInteractive televisionMultiplication signForm (programming)QuicksortNonlinear systemMereologyLimit (category theory)Mathematical modelState of matterSemiconductor memoryDigital electronicsLevel (video gaming)LaserOptical disc drivePhase transitionFluxConnectivity (graph theory)Hamiltonian (quantum mechanics)Line (geometry)Constructor (object-oriented programming)Parity (mathematics)Right angleBitCircleIdentical particlesSound effectTheoryComputer simulationNumbering schemeTwo-body problemInformationFunction (mathematics)OpticsAsynchronous Transfer ModeVacuumoutputQuantumMeasurementSimulationParameter (computer programming)Volume (thermodynamics)Natural numberFrequencyDirection (geometry)Term (mathematics)Order (biology)PhysicalismPhysical systemRevision controlOcean currentMathematical modelAtomic numberScatteringKey (cryptography)Type theoryContext awarenessResonatorControl flowFormal grammarStability theoryVideo projectorError detection and correctionProjective planeQuantum entanglementOperator (mathematics)Differential equationField (computer science)WechselwirkungsbildQubitSelectivity (electronic)Uncertainty principlePropagatorHarmonic oscillatorFunktionalanalysisPotenz <Mathematik>Bit rateHarmonic analysisMiniDiscSingle-precision floating-point formatSet (mathematics)Autonomic computingTensorTrajectoryError messageSurjective functionComputer animation
23:16
Digital electronicsDiscrete groupAnalogyMatrix (mathematics)1 (number)MeasurementAngleIterationParity (mathematics)RotationNoise (electronics)Quantum circuitDifferent (Kate Ryan album)Mathematical modelQuicksortPower (physics)Sound effectDigital electronicsSingle-precision floating-point formatVacuumCASE <Informatik>FrequencyLine (geometry)Product (business)Function (mathematics)InformationRevision controlLimit (category theory)OpticsPhase transitionMereologyKnotControl flowMultiplication signQubitComputer animation
25:00
Graph (mathematics)SequenceMeasurementParity (mathematics)ScatteringCodeWechselseitige InformationAerodynamicsMarkov chainInformation managementError messageVideo trackingHybrid computerInfinityHydraulic jumpContinuum hypothesisContinuous functionMathematical modelDiagramBitError messageProcess (computing)Group actionQuicksortPhysical systemQubitStochastic processRandom measureState of matterVorwärtsfehlerkorrekturSimulationMultiplication signMeasurementControl flow3 (number)TrailFinitismusPosterior probabilityLikelihood functionRandom walkDynamical systemNichtlineares GleichungssystemRight angleCartesian coordinate systemPlotterState observerParity (mathematics)Arrow of timeSingle-precision floating-point formatBit rateInformation1 (number)Tracing (software)Semiconductor memoryNetwork topologyLine (geometry)Type theoryCore dumpVector spaceProcedural programmingFilter <Stochastik>NeuroinformatikDifferent (Kate Ryan album)Student's t-testGraph (mathematics)SequenceResultantRandomizationAreaMassComputer simulationControl theoryPositional notationMathematical modelMathematical optimizationNoise (electronics)FehlererkennungQuantumZustandsgrößeGreen's functionComputer animation
31:14
MeasurementControl flowFaculty (division)TheoryProgramming paradigmQuantumControl theorySystem callCross-correlationInformationQuantum entanglementControl flowConstructor (object-oriented programming)Physical systemBelegleserRight angleState of matterInteractive televisionClassical physicsFeedbackScatteringQuicksortMeasurementLaserDecision theoryFehlererkennungNeuroinformatikField (computer science)Module (mathematics)Process (computing)Real-time operating systemFunction (mathematics)Electric fieldRoutingMultiplication signCentralizer and normalizerFundamental theorem of algebraContext awarenessMereologySign (mathematics)Dynamical systemChannel capacityDigital electronicsPoint (geometry)Logic synthesisGame theoryView (database)VorwärtsfehlerkorrekturBitSemiconductor memorySet (mathematics)Slide ruleConnected spaceSelectivity (electronic)Control systemoutputSpektrum <Mathematik>Mechanism designWechselwirkungsbildHeegaard splittingQuantum mechanicsDigital photographyComputer animation
35:45
Semiconductor memoryQuantumContinuous functionMathematical modelMathematical modelComputer networkEuclidean vectorDiagramIRIS-TAnnulus (mathematics)Confidence intervalNichtlineares GleichungssystemIdeal (ethics)INTEGRALAsynchronous Transfer ModeLimit (category theory)Descriptive statisticsOrder (biology)Mathematical modelHookingRandom matrixGroup actionMathematical analysisFormal verificationParameter (computer programming)Mathematical modelSlide ruleCuboidDimensional analysisQubitRoutingQuicksortoutputVolume (thermodynamics)BitOperational amplifierLatent heatSpacetimeMultiplication signCohen's kappaConnectivity (graph theory)State of matterFunction (mathematics)SoftwareMatter waveSemiconductor memorySymbol tableField (computer science)Serial portCircleAdditionConnected spaceRight angleFehlererkennungOpticsParity (mathematics)Zoom lensQuantum entanglementDiagramType theoryError messageLaserLine (geometry)Single-precision floating-point formatAtomic numberDigital electronicsTensorproduktQuantum circuitElement (mathematics)Operator (mathematics)Central limit theoremFrame problemVideo projectorSoftware developerDifferent (Kate Ryan album)QuantumControl flowAlpha (investment)Computer simulationHierarchyPower (physics)Level (video gaming)Range (statistics)Matrix (mathematics)Term (mathematics)TunisMeasurementLattice (order)WaveTrianglePhysical systemMedical imagingCASE <Informatik>Electronic program guideInteractive televisionDependent and independent variablesTwo-dimensional spaceTraffic reportingData structureBeta functionProteinMetreTheoryError detection and correctionSpring (hydrology)Diffuser (automotive)Set (mathematics)AlgebraComputer animation
43:49
Nichtlineares GleichungssystemSimulationGamma functionMIDIQubitOperator (mathematics)State of matterCellular automaton2 (number)State observerLimit (category theory)Dynamical systemDigital electronicsConnectivity (graph theory)Nichtlineares GleichungssystemError messageTerm (mathematics)Product (business)QuicksortQuantumParity (mathematics)Set (mathematics)Semiconductor memoryHydraulic jumpAutonomic computingWeb pageMathematical modelVolume (thermodynamics)Interpreter (computing)LogicTable (information)FehlererkennungCalculationType theoryReal numberFunktionalanalysisForcing (mathematics)Binary multiplierSigma-algebraGroup actionReal-time operating systemCross-correlationPhysicalismCentral limit theoremMultiplication signEvoluteVideo projectorMereologySurjective functionControl flowQuantum circuitMeasurementDensity matrixForm (programming)OscillationBitMathematical modelHamiltonian (quantum mechanics)AreaEuler anglesClassical physics1 (number)Nonlinear systemPower (physics)Key (cryptography)VorwärtsfehlerkorrekturPropositional formulaAlgebraMagnetic-core memoryError detection and correctionNatural numberControl theorySocial classDiagram
48:39
Semiconductor memoryQuantumQuicksortParameter (computer programming)Type theoryField (computer science)Latin squareInteractive televisionEvent horizonState of matterVorwärtsfehlerkorrekturLevel (video gaming)Degrees of freedom (physics and chemistry)Control flowEquations of motionTerm (mathematics)Hamiltonian (quantum mechanics)Limit (category theory)Cross-correlationBitFehlererkennungEngineering drawingDiagram
49:30
Nichtlineares GleichungssystemSimulationQubitParameter (computer programming)State of matterNumerical integrationBitTerm (mathematics)Range (statistics)Different (Kate Ryan album)Operator (mathematics)Parity (mathematics)Error messageMathematicsFitness functionRight angleCategory of beingCubeFlow separationQuicksortVorwärtsfehlerkorrekturFeedbackNichtlineares GleichungssystemDiagram
50:36
Insertion lossQuantumNichtlineares GleichungssystemSimulationPropagatorInsertion lossData transmissionQuicksortCategory of beingSoftwareMathematical modelWaveDigital electronicsNetzwerkdatenbanksystemElectronic program guideParameter (computer programming)FunktionalanalysisVorwärtsfehlerkorrekturComputer animationDiagram
51:24
QuantumSemiconductor memoryComputer networkMathematical modelEuclidean vectorCodeExtension (kinesiology)Independent set (graph theory)Data structurePolarization (waves)State of matterLevel (video gaming)Atomic numberDigital electronicsField (computer science)QuicksortType theoryMeasurementImplementationError messageQubitRow (database)QuantumPhysicalismFehlererkennungUniqueness quantificationMultiplication signVorwärtsfehlerkorrekturComputer animationEngineering drawing
52:20
Control flowDigital electronicsInformationClassical physicsField (computer science)QuicksortTheoryFeedbackImplementationControl flowFehlererkennungPhysical systemMereologyQuantumFood energyQuantum fluctuationMultiplication signBuildingLogicProcess (computing)Logic gateView (database)Form (programming)Digital electronicsMathematical modelCore dumpGroup actionComputer animation
53:49
Stability theoryOpticsControl flowSimulationQuantumDigital electronicsMathematical modelVisual systemDynamic random-access memoryComputer hardwareFormal languageHardware description languageMereologyNumerical analysisMIDIAerodynamicsPhysical systemMotion captureFreewareDescriptive statisticsoutputDigital electronicsSymbol tableTerm (mathematics)Connectivity (graph theory)Open setQuicksortOpen sourceVorwärtsfehlerkorrekturMathematical modelPropagatorBuildingInformationStreaming mediaClassical physicsComplex analysisQuantumQuantum entanglementCalculationInsertion lossProcess (computing)OpticsComputer animation
54:50
AerodynamicsControl flowOpticsVisual systemDigital electronicsQuantumSemiconductor memoryInformationProcess (computing)QubitQuicksortFunktionalanalysisKernel (computing)Calculus of variationsState of matterDigital electronicsError messageRegular graphControl flowMereologyoutputForm (programming)Right angleOperator (mathematics)Range (statistics)OpticsMathematical modelSoftware frameworkPower (physics)BitClassical physicsLimit (category theory)Spectrum (functional analysis)Flow separationPoint (geometry)VorwärtsfehlerkorrekturPlanck constantMultiplication signStochasticTerm (mathematics)Quantum entanglementQuantumEvoluteComplex analysisDynamical systemExtension (kinesiology)Uniform resource locatorStability theorySpacetimeSurfaceElectric generatorGroup actionConditional probabilityFeedbackHybrid computerComputer simulationNoise (electronics)Mathematical analysisSemiconductor memoryFehlererkennungCost curveCASE <Informatik>Population densityMeasurementResultantDimensional analysisVolume (thermodynamics)Physical systemGreen's functionMiniDiscData storage deviceSinc functionFood energyScaling (geometry)Division (mathematics)Three-dimensional spaceBit rateInformation securityMathematical optimizationAreaEngineering drawingProgram flowchartDiagram
Transcript: English(auto-generated)
00:00
given by Hideo Mabuchi from Stanford University. And as you see, we see something about design and analysis of autonomous quantum memories. Please, Hideo. Thank you very much, Rainer. I should certainly start by thanking the organizers of this workshop for the opportunity to be here and to give one of these extra special keynote addresses.
00:20
I hope you won't be terribly disappointed as this talk will include neither group theory nor filter functions. But I'll try to say something else interesting instead. So the topic, as noted, is design and analysis of autonomous quantum memories based on coherent feedback control. And really, the theme is just kind of a case study on how one can take the key ideas about quantum error
00:43
correction that come from the standard formalism of stabilizers and coding, unitary maps, all that kind of thing, but really push those ideas down to a physical level of modeling, which is maybe a little bit closer to the kinds of things that engineers and experimental physicists would like to think about. And in our workshop, we've heard
01:01
about a lot of very elegant work on how to do that kind of pushdown of kind of taking these ideas and going down to the level of Hamiltonian interactions from these lattice types of models, which one could maybe say are couched in a language which is more familiar to people working maybe on atomic optical lattices or even these days in condensed matter systems.
01:21
And maybe you could think of the idea of this work would be to do the same sort of thing except to really connect those ideas to things that are a little bit closer to current developments in experimental photonics. And maybe some of those ideas can also be carried over into the world of circuit QED and microwave quantum information processing. So let me also acknowledge that the kind of precursors
01:42
of this work were supported by ARO. The current and continuing work is supported by the NSF. And if I have time at the end, in terms of kind of contextualizing this work and connecting it to some other things that are going on, I may make mention of some stuff which is supported by DARPA. So really the idea is to get to a formulation
02:03
of a quantum memory, which is based on the usual ideas of coding and syndrome detection and restorative feedback, but to really learn how to do that in a system which is completely microscopically described. So actually for the analogy, I like to resort to the microwave story of the superconducting circuits, your actual quantum dynamical stuff is down in the door.
02:22
Maybe even you've got some pre-amplifiers down in the door, but generally if we're talking about doing control or even a real-time feedback control, you've got signals that have to come in and out of the door. They have to come back up to room temperature for the classical computation and then go back down. And this is all kind of a way to short circuit that and just do all of the processing that's necessary
02:42
for the feedback control for quantum error correction down in the door or in the photonics case to do everything really at nanoscale without requiring any classical control signals to come in and out of the quantum memory. And there are really three main ingredients to talk about in order to explain how that whole thing gets set up. First of all, I'll introduce some simple ideas
03:01
about how to do syndrome detection in continuous time. I think there, again, are various approaches to doing this kind of thing. I'll explain the one which kind of feels most natural from a quantum optics point of view. And I'll try to build a little bit of intuition about how things like signal-to-noise ratio in a continuous syndrome measurement translates into the actual performance of an error-correcting code.
03:23
I'll then talk a little bit about the idea of coherent feedback control and the idea of doing the feedback without ever bringing the signals up to a classical level. And then in order to actually construct an overall model of how the autonomous quantum memory is going to function I'll just introduce a few ideas from control theory
03:41
about what's called SLH modeling of quantum optical input-output components and make some connections to current things going on in control theory. And all of that will add up then to a relatively simple picture in the end of how this kind of autonomous or embedded quantum American controller is supposed to work, but one which I think is very satisfying for us.
04:03
I'm not necessarily saying that this is how one should go out and build quantum memories, but I think the ideas that are demonstrated there form a very nice, provide kind of a lesson on how quantum information ideas can really be brought into the mainstream of what people are doing in nanophotonics.
04:20
So I mentioned this idea about trying to take ideas from quantum error correction and push them down into the physical level of modeling in photonics. And as many of you know, photonics is something which is very seriously being pursued not only in academic research groups, but in industry. So this is just to flash up a slide from our colleagues over at HP Labs, which is just across the street from Stanford University.
04:43
And they have a fairly serious investment in what they call large-scale integrated photonics. Photonics on one end connects to very quantum mechanical things. So there's a lot of work being done these days on embedding quantum dots or nitrogen vacancy centers or other sorts of atom-like solid states into a nanophotonic lithographically defined resonators
05:02
so that you could do kind of a solid state version of cavity QED. And that obviously is highly analogous to the sorts of things that people have done in a single atom cavity QED, things that people are doing in microwave circuit QED. At the same time, I think the investments that a company like HP is making in nanophotonics
05:21
is actually not so much driven by the ultimate goal of quantum computing, but rather just by the realization that as you look at the future scaling of conventional computer processors, so just sticking within the informational paradigm of classical information processing, there are severe bottlenecks looming not so far down the road, maybe five, 10 years down the road
05:41
about how to really bring down heat dissipation and how to solve kind of power bottlenecks, both in computing and even just in transporting information around on a chip. And it's thought that if you could learn to build a large-scale integrated photonic systems, this might be a good way to kind of hybrid computer chips that might still do their computation
06:00
using CMOS transistors, but where maybe information is moved around in optical form. So there's a large industrial base being built up for working with photonics as an information processing physical paradigm. You know, currently with a large focus on classical information processing, but as I'll try to argue through this talk, it's a very small step, I think, to generalize some of that to do quantum information processing.
06:22
That was a, I mean, if you really take it to the limits of integration, so this is a slide that I downloaded off of the web from a current project running at IBM where they've become very serious about large-scale integration in silicon photonics. And so, you know, they can have these photographs like this of large-scale wafers, and you zoom in and find that they're able
06:41
to string together large sequences of very complex sorts of components and really make things that look like circuits for light waves as opposed to circuits for electronic voltages and currents. So, you know, to make contact to that world, sort of introduce a friendly way to think about things like quantum error correction
07:00
that very naturally maps onto that sort of developing fabrication technology, to me, one of the key things that has to be done is to take the view of quantum error correction, which has largely arisen in the kind of thought paradigm of computer science and digital signal processing, and really pull it back down to a kind of earlier,
07:20
more primitive state of electrical engineering, which focused on analog components and in different kinds of circuit diagrams, right? So at the very top of this page, I've written something which is, it's a little bit weird, but you'll recognize the notation as being that of what we, at a workshop like this, typically when people say quantum circuit, they mean something like what's drawn at the top.
07:42
But if you think about what that diagram really is, Dave Bacon, in his talk yesterday, just put the labels on that there's time going across the horizontal axis, and there's a kind of implicit one-dimensional space axis going across the top. So really, that thing is not so much a circuit diagram we might learn about in elementary electrical engineering courses
08:00
in graduate school, it's really kind of a graphical pseudocode that specifies an algorithm for what's supposed to happen. Right? And contrast that to this diagram that's drawn in the middle of the page, where this is, you know, if you've done some electronics, this is very familiar to you. There is an operational amplifier with a resistive feedback network, providing negative feedback to turn this thing
08:20
into an inverting amplifier. And there's a big difference in that, although this middle diagram is still something kind of schematic, right, the components are depicted in a cartoony sort of form, it nevertheless actually shows you what physical devices are supposed to be plugged into your circuit board, roughly where are they supposed to be in relation to one another,
08:40
how are the outputs and inputs of these different components supposed to be connected, and the idea of this kind of thing is that if you actually make such a circuit layout, right, so you make the operational amplifier and the two resistors or capacitors or whatever, if you put them in this, if you lay them out kind of like this, connect their inputs and outputs in this sort of a topology, once you've made that circuit,
09:00
all your work is done, right? The only thing that you need to do in order to have this little circuit actually function is you just have to power it, right? And so that's, I think, the kind of paradigm which is familiar from classical electrical engineering, and the question that we've been asking is, well, can you do a similar sort of thing to the idea of quantum error correction,
09:20
but now adapted to the kinds of devices and layouts that one can imagine in the maybe not too distant future in the nanophotonics platform? So this image that's at the bottom, something that I stole from my colleague Elena Butchkovic, it's just an electron micrograph of a photonic crystal membrane, so this is the top view of a two-dimensional thin dielectric membrane,
09:44
a series, an array of holes have been punched in it, so the little holes are the ones that are relevant, and kind of you pad around some little structures, so there's an obvious stripe that goes down the middle, that thing functions as a waveguide for light, it's a wire at the two ends, it's probably hard to see, but there's a, after a little bit of a gap,
10:02
there's another little kind of dot there, and that little dot functions as an optical resonator, there's another one of them down at the other end, and so this is very simply a device where you have two input-output optical components connected by a wire, and so the kind of grand idea of this is to move towards a paradigm where what we'd like to be able to do is to specify, at least in some schematic kind of way,
10:23
analogous to the op-amp diagram in the middle of the slide, how to lay out nanophotonic components of a specifiable type, such that you would go into your E-beam fab and make a thing like this, which would be a nanophotonic circuit, which then just existed as a solid hunk of stuff, and in order to get that circuit
10:41
to perform continuous quantum error correction, the only thing that you would need to do is to provide it power, right? So that it would be a lot more like this circuit that's drawn in the middle of the slide, and a lot less like the kind of algorithmic, step-by-step synchronous sort of thing that's implied by the diagram that's written at the top.
11:02
So first, let me kind of ease into this idea of going from discrete step-by-step pictures of quantum error correction into how we would think about doing error correction in continuous time without running into any sorts of issues about quantum Zeno paradox or anything like that. So in almost all of the talk, I'm just gonna be focusing on
11:21
the simplest possible quantum error correction code. So I'll just talk about the three-qubit bit flip code. Nevertheless, all of the ideas that are presented here generalize in a very straightforward way to other sorts of stabilizer codes. And so I'll at least briefly show a diagram of a similar sort of circuit for doing a bake-and-shore version of the nine-qubit code
11:42
that corrects an arbitrary single-qubit error. So, but just for the bit flip code, the only thing that you really need to be able to do is to make parity measurements on the Z-parities of pairs of qubits in the register. Single logical qubit as the entangled state of three physical qubits in a register, logical zero represented by zero, zero, zero,
12:01
logical one represented by one, one, one. And in order to read out the syndrome of a possible error, what you wanna do is read out at least two different parities in that register, right? So you might look at Z one, Z two, and also look at Z one, Z three, or you could choose any other pair like that.
12:20
So in order to think about how one does that in a continuous way, as opposed to the usual kind of picture that would involve a controlled, controlled gate, and an ancilla, just consider the following idea, which is, you know, more or less follows from things that have previously been done in the literature. And there's some alternatives to this very idea, one of which is described by Anne Nielsen
12:40
in a 2010 paper. But suppose I have a coherent state of light, so single spatial mode, coherent state. So at least in some approximation, this is the kind of light that just comes out of an ideal laser. So the coherence is fully specified by a single complex number, that's the complex amplitude. The magnitude of that complex number
13:00
tells me how much power is in that beam, and the phase of the complex number tells me the phase of the coherent state. And so the notation here will be just in a Dirac head, if I put the number alpha, that's the complex number that represents the complex amplitude and phase of that coherent state. So in a certain scattering phase convention, if I just take such light and I reflect it off of an isolated mirror,
13:23
right, so the laser beam comes in, reflects off the mirror, and that's it, well, I can choose a phase convention in which under that type of reflection, the phase of the coherent state is unchanged. Now under that same phase convention, if I consider instead that I have two ideal mirrors and I place those mirrors face to face
13:42
and I make a little resonant cavity, then under the assumption that the frequency of this coherent state is resonant to the spacing between the mirrors, so roughly speaking, if the wavelength of the light fits an exact integer number in the distance between these two reflecting boundary conditions, then I'll be driving that cavity on resonance. If I assume that that's an empty cavity
14:02
and maybe it's a single-sided cavity, so that the light goes in and out in one side of the cavity only, then under those same kind of scattering conventions, if I look at what happens to the phase of the probe beam, then rather than bouncing off of the cavity and having no phase change, it actually suffers a pi phase change. And so in order to put a qubit into the story
14:20
and talk about how this starts to be something like a sigma z measurement, we can choose as the physical carrier of the qubit of information if we pick something like a typical atomic level structure. So this little thing inside of the, that's drawn inside of the cavity, so here.
14:43
So if we, if this guy and that guy, if those are the two end mirrors of the cavity, my resonant probing beam is coming in this way, if I imagine that inside of that cavity I have this atom-like object which has maybe two stable ground states and one electronic excited state, I could imagine that the level spacing
15:02
between this ground state and that excited state is resonant with the transition frequency of the cavity, whereas the energy between this lower ground state and the excited state is off resonance. So what that would mean is that if I have, and the idea would be then to encode the qubit in the coherent superposition of these two ground states. So if the atom inside the cavity
15:21
is prepared in this lower ground state, then the transition that's accessible is not the one that's resonant to the cavity mode. So if the qubit is in this state, this probe beam comes by and drives the cavity, it still looks like an empty cavity and so we would get this pi phase change. On the other hand, if the atom happens to be in the other logical state, then this accessible transition
15:41
is resonantly driven by light in the cavity and because of the now familiar physical phenomenon of vacuum Rabi splitting, what happens in that case is the light is still perfectly reflected from the cavity, but if you work out all the details and then picking up a pi phase change, it again picks up a zero phase change. So what that says is that in terms of a single qubit like this, if we just take a coherent laser probe
16:02
and bounce it off of the cavity, then depending on whether the embedded qubit is in a logical zero or a logical one, this coherent state will either pick up a pi phase shift or a zero phase shift. So now you get very easily the idea about how to do a parity measurement. So if I just have this same optical probe beam reflect sequentially off of two different qubit cavity systems,
16:22
so there's two different qubits, will be two of the qubits in the register, the cavities are there really just to enhance the coupling between the probe beam and the atoms, but the net effect will be that if the qubits are both in the down state, then the phase shifts picked up by the probe beam will be pi and pi, but of course for an optical beam, a two pi phase shift is the same thing
16:41
as a zero phase shift. If the two qubits are in the one one state, then I'll get phase shifts of zero and zero, so I'll get that zero phase shift. But if I have one zero or zero one, then one of the reflections will give me zero, and so overall the phase shift of the probe beam will be pi. So you end up with something where now you've used this continuous probe beam
17:02
to determine the parity of the two qubits, and the result is encoded in the phase of the outgoing probe beam being either zero or pi. And so of course a kind of larger question in a lot of these businesses of trying to create physical realizations of the ideas of quantum error correction, especially if we try to engineer it at this very low level,
17:21
that all of this stuff that goes on in the stabilizer formalism, all of the non-trivial stabilizers are two-body operators that you're trying to measure. And sort of implicit in that is that, well, if we're gonna do this measurement in some sort of indirect way where there's either an ancilla qubit or a field like this, if you wanna try to measure a two-body observable, then really the Hamiltonian that you're supposed to be using
17:41
to make the coupling is always supposed to be a three-body Hamiltonian, but nature doesn't really give you any of those to work with, so you have to synthesize them somehow. And so of course there are lots of tricks that have been invented on how to do that, but so you very quickly realize that, well, if I have a Hamiltonian, which is a two-body Hamiltonian, but then if I think about propagators which are exponentials of those,
18:00
if I can take those propagators and somehow pull out something nonlinear, that's really what I need to do in order to synthesize those three-body interactions. And here we get to use a very simple sort of form of the nonlinearity, which is simply the fact that this kind of phase of a coherent beam lives on a circle rather than on a line, right? And so that's what's giving us the nonlinearity that allows us to make something that really looks like a two-body parity measurement
18:23
as opposed to something else. So just to show that, okay, so a thing that you can do to analyze exactly what goes on, obviously this is the simple picture, but you would really like to see how well does this kind of scheme perform under a more exact kind of physical model.
18:42
You could write down the James Cummings interaction Hamiltonian between this embedded qubit and the cavity mode. You have some nice quantum optical input-output theory about how the probe beam really interacts with that whole thing. And the thing to know using some recently developed kind of quantum optics theory is that in the limit, where both the Rabi frequency
19:01
that couples the qubit to the cavity and the cavity decay rate are both large, but where the ratio of those two things is fixed at some more or less arbitrary value, then the input-output model for this kind of a scattering system goes over exactly into a sigma-Z measurement. And so that's the theme we're gonna come back to a few more times in constructing the overall circuit model,
19:21
which is that although we understand how to write down explicit physical model for these things in terms of microscopic physics like the James Cummings model, it turns out that for the kinds of components that we've designed, if you consider this limit where both the Rabi frequency and the cavity decay rate, when those both go to infinity
19:42
compared to other parameters, then the effective scattering models for all of these components will greatly simplify. And that's really the key to allowing us to construct an overall circuit model that this quantum memory will work using an actual continuous time differential equation sort of model. And that particular limit, I think is a very natural one
20:00
for this nanophotonic setting. So you get the idea that using e-beam lithography or other such techniques, you can make very, very small resonators in the nanophotonics context. And so as you go to this small volume limit, the thing that very naturally emerges for cavity QED type models is that G gets very large and Kappa gets very large, right? So the vacuum Rabi frequency and the cavity decay rate
20:21
naturally both get large at the same time in the small volume limit. And that's exactly the parameter limit that we wanna consider for the functional models of these sorts of devices that we want in this basic business of designing autonomous quantum memories. But just to confirm that this kind of thing can work reasonably well using say currently accessible experimental parameters,
20:41
if you just mock up in a quantum trajectory type of simulation in a situation like this where we've got atoms coupled to two cavities and we allow a laser beam to scatter off of them. And then we do something to really prepare a state for these two qubits, which is factorizable. So we have zero plus one tensor zero plus one. So if that's our initial state,
21:01
but then we turn on this sort of continuous parity measurement, then what should happen after some time has gone by, is that by detecting the phase of the outgoing beam, that should project either onto zero or pi, which then project out either the even or odd parity component of the initial factorizable state.
21:20
So we should actually create an entanglement there. But there's a little bit of a question about how that dynamic should actually look in time. So here's an example of a quantum trajectory simulation, which shows the projection of the conditional state as a function of time onto either the even or odd parity component. And so they start out both at half, but you see that they kind of wiggle around for a while
21:41
before settling down. In this model, we've also got occasional bit flips. So there's a bit flip that occurs here in this particular simulation. So the parity measurement catches up and realizes that's happened. But you see that kind of by construction in this sort of a very physical model of the parity measurement, the measuring the parity of the two qubits takes an amount of time, right?
22:02
So there's a finite rate in which you actually get information. And it's very easy to see why that should be, right? Because for those of you who are used to thinking about coherent states of light beams or harmonic oscillators, you know, the vacuum state, that's something which has zero complex amplitude, but it's got a certain quantum uncertainty to it. And so now if we talk about making a coherent state,
22:20
that means that we displace that uncertainty disc along some direction. And that would be maybe like the zero phase version of the current state amplitude. If we give it a pi phase shift, that means we bring it over here, right? But in order to really be able to distinguish those zero and pi phase states very well, you actually need to separate their amplitude by quite a bit, right? Because otherwise their uncertainties are overlapping.
22:41
And in this sort of picture, what that just means is that the flux of photons coming from the lasers is finite. You have to, you know, when you've just turned that thing on and only like one photon through and scattering off of both of the cavities, you know, that single photon's worth of amplitude doesn't really distinguish those two states enough. But as more and more photons come through, then the sort of effective amplitude pulls out.
23:01
And so gradually over time, you're able to distinguish the fact that the scattering phase shift overall is zero or pi, right? So that kind of the drawn out in time nature of this kind of a measurement is very naturally captured in this sort of physical model. And so, you know, if you really want to relate all of this stuff back to
23:21
what would this look like in the usual sort of a quantum circuit setting, I think I've accurately drawn on the top there a sort of effective model for what's going on. So it would still be the case that I've got a, kind of a three register qubits, which are the three lines at the top. There'll be two ancilla qubits running along the bottom representing the outputs of the two
23:40
different parity measurements that you need to make. Here a one two parity and a one three parity. And if you use this kind of circuit where you had controlled controlled knots, then obviously one iteration through this thing, you could perfectly measure those parities that you want to measure. But if on the other hand, you consider making those controlled controlled knots, and you turn them into controlled controlled rotations, where the rotation angle was something very small,
24:02
but then you increase the frequency with which you do these things, right? So you do a smaller and smaller conditional rotation angle, but you do more and more of these measurements per unit time, that will take you over to this continuous measurement limit, right? So where just a single click in the detectors that are looking at the ancilla qubits, a single click doesn't give you
24:21
any definitive information about the parity if the conditional rotation angle is very small. But if I do this over and over again and do many of them, eventually I can add that up and I can kind of statistically average out the noise and I can determine what the parities are. And so this optical version of this, where we're talking about phases or a homodyne measurement or whatever, it's a lot like this kind of a setup where the power of the probe beam
24:42
and other things related to the strengths of the vacuum robin frequencies and whatnot, those go into determining something like the product of the kitchen angle and the frequency with which those measurements are made. Right, so there's a notion of information per unit time, which in the optical limitation has mostly to do with the strength of the probe beam.
25:01
So I mean, imagine if we really were trying to just do this in the usual error correcting sort of setup. So we would literally as suggested in this diagram back here, that we would allow this probe beam to bounce off of the cavities that contain the qubits. We would do our best job of trying to measure the phase shift of the outgoing probe beam. And say we tried to take that noisy signal
25:21
and do something with it and try to sort of use that to determine when a bit flip had occurred and then went back in to perform some restorative action. What would that overall, how would that overall system perform? Well, let me introduce a kind of notation that we've used in some other publications on that topic where, so in this kind of a setting,
25:40
you can imagine that, well, what we're trying to do is estimate the error state of the code based on these sorts of continuous noisy measurements. So initially when your register has just been initialized in its logical state and at very short times where you're pretty sure no error has occurred, you can say that the state of the code is I-I-I in the sense that no error has occurred. And then if some time goes by, then there's increasing likelihood
26:01
that you may have suffered a bit flip on at least one of the qubits. So you might have to consider the error states X-I-I, I-X-I, I-I-X, in the obvious kind of notation. Likewise, two errors would be represented by things like X-X-I, X-I-X, I-I-X. And eventually you might get to the state where all of the bits have been flipped, that would be triple X. But of course, since these bit flips are happening
26:22
as a random process, kind of any of the transitions that are drawn by arrows are allowed, right? So if I start from I-I-I, make a single bit flip, I go to I-X-I, then maybe the last qubit flips, I go up to I-X-X, then I might go down to I-I-X if the middle bit flips again, right? So the actual dynamics of the error state of the code is a random walk on this kind of a graph.
26:41
And really you can view it as your job in an electrical engineering sort of way to say, all right, so I've got these two noisy, continuous time measurements of a pair of parities. So what I'm trying to do is to use that information to optimally reconstruct a posterior probability on this graph, right? So at time T equals zero, I'm sure that my register
27:01
is still in a perfect state. So I assign the probability vector that has value one on I-I-I and zero on all the other nodes. But then as time goes by, like in a small time step where maybe one error has occurred, if I don't do any detection or anything like that, then that probably is gonna start to smear out to that first column of different states.
27:20
And if the errors are happening fast compared to the information rate in my measurements, that probability will continue to smear out in this graph and eventually I'm screwed. But if your information gain rate is fast enough compared to the rate at which errors are occurring, then the conditioning on the measurements that you've received allows you to kind of keep the probability mass localized, mostly at least on one of these error states.
27:43
And what you're trying to do is sort of construct the model that will do that in an optimal way. Interesting to see is that this business of looking at a random walk on a graph based on measurements that come to you in Gaussian noise, the optimal state estimator for such a problem was actually written down in 1965 by a guy named Wanam.
28:03
So the Wanam filter is actually the optimal numerical procedure for doing that in a recursive way where you're trying to do this in real time. And so actually the problem of how to do that is something that's solved, and we can take that for granted. And so if you start to do some simulations of that sort of process,
28:20
so here what we're doing is we take a three-qubit code, initialize it in some logical state, and then we simulate in a continuous time sort of way both bit flips that might be acting on the qubits of the code, and we're also simulating these continuous noisy measurements of the pair of parities. And so what's drawn in the simulation plot at the top is initially we start out with a probability value of one
28:40
assigned to IAI, and then we're just gonna look at the probability values, the posterior probabilities that are assigned to the single error state function of time. So up on the top there, time is on the horizontal axis. You'll see that there's a black trace that starts out at one, and then the red, blue, and green traces start out at zero. As time goes on, we have some kind of wiggly features
29:01
at that horizontal green dashed line. There in this particular simulation, the bit flip actually occurs on the first qubit, so the actual state of the code goes to XII, but then the posterior reconstructions of that state, as determined by the quantum filtering equations, are shown, they have a little bit of latency, so because of the fact that you have finite information rate coming out of your measurements,
29:23
it takes a little bit of time to notice that that bit flip has actually occurred, but eventually, in fact, the green probability does go up close to one, and the other ones come back down close to zero, so that's one feature of this sort of system. And then you also notice that actually even before that bit flip occurs, there's this funny little hiccup at about 4.3, where there's a little bit of a glitch
29:41
where the probability of one goes down and the other ones go up. So generally, in these sorts of systems where you don't have instantaneous perfect measurements, but rather you have these continuous, noisy, finite rate of information comes with measurements, there's latency and detecting errors, and there's also some false alarm rate. These are things that people have studied in control theory forever,
30:00
but these are the kinds of things that regardless of how we actually implement the error correction or the error tracking, whether we do that using a classical computer propagating the quantum filtering equations, or whether we do that using a coherent feedback setup of the type that I'm about to describe, we should imagine that because of the finite rate of information gain in the parity measurements, there always will be these non-idealities,
30:21
and eventually those things will catch up with you. So eventually the fact that you have latency and the fact that there's a finite rate of false alarms, just due to anomalous sequences of the random measurement results, your fidelity will decay in an irreversible fashion. But kind of the better your code is, or the better your memory is,
30:41
the more you will slow down the actual decay of fidelity as compared to the situation where you don't encode your own. Okay, so that's just a little primer on continuous syndrome detection. Next I'll move on to talking a little bit about the ideas of coherent feedback and how you might use this kind of a probing setup
31:01
to actually diagnose the syndrome and to try to correct the errors without ever actually sticking a photo detector in your setup and without bringing these signals necessarily back up to a kind of macroscopic controller. So this starts to make some interesting connections between the whole business of quantum error correction
31:21
and kind of a major theme in quantum control theory that's developed over the past few years. And so I think by now many people will recognize the kind of setup that's drawn on the right-hand side of this slide, where we have some quantum mechanical input-output system, which is the system we're trying to control, and the control theoretic jargon, you usually call that the plant.
31:41
And so for many years, people have been considering situations where some probe beam goes into the plant, maybe it's a laser probe, so the laser scatters off of the things inside the plant, their states become correlated, laser beam comes out of the plant, you send it to a photo detector, right? So that destroys the outgoing probe beam, you convert those entanglements into classical correlations
32:00
between the information in your electrical signal and what's going on with the conditional state of the plant. Based on that information, you've got some kind of a classical circuit or computer, which tries to extract updates about what's going on with the plant dynamics, possibly with the perturbation dynamics, and the classical controller makes some decision about ways to act back on the plant
32:20
to try to correct the way that it's evolving, and typically those corrections are done by either altering the way that laser beams are going into the plant, or maybe you modulate other things like magnetic fields or electric fields or what have you. And so that's a picture that now we would call measurement feedback control, right? So it's really real-time feedback control in the sense that within the coherence time of the plant dynamics,
32:41
we're trying to execute many such loops of detection and feedback, but real-time, but it's measurement-based in the sense that when quantum fields come out of the plant, we detect them, and then really only propagate classical information for a while, and then do something that acts back on the plant. So in a certain sense, you could maybe just say that the feedback loop itself has zero quantum capacity by construction.
33:03
On the other hand, one can obviously think about a situation more like what's on the left. This is what we'll now call coherent feedback quantum control. It's not a new idea. You can find very interesting papers on this kind of thing in the electrical engineering and quantum optics literature going back into the 80s at least.
33:20
But so here you have the same sort of situation where there's a plant, which is the thing that you're trying to control. Some laser beam goes into the plant, scatters, becomes correlated, but now when that laser beam comes out, rather than detecting it, you now round it out, without that output laser beam through another physical system, which kind of processes that information in a coherent sort of way, and then that laser beam loops back
33:40
and gets re-injected into the plant. So you end up closing a control loop, which is fully coherent, in the sense that we never assume that there's any measurement going on, at least not necessarily so. From an experimental point of view, really what this is, is you're just making some kind of a giant interferometer. But I think what's been interesting in the control theory literature recently is that if you were gonna think
34:01
about designing large controllers like this, where there's one piece of the interferometer, which is given, and you're trying to design the other piece of the interferometer, so that you control the dynamics of the first part in some desirable way, that's now the business of coherent feedback control synthesis. And so there's been some interesting work to relate that kind of design problem to methodologies that are already known
34:22
in the context of control theory. And from a very fundamental point of view, what's interesting about that maybe is that, now you can have situations where the quantum capacity of the feedback loop is non-zero. And I think it's interesting to ask how that changes the game. I will note ahead of time that in the coherent feedback controller that I'm gonna show you for the error correction codes,
34:42
we don't use that quantum capacity, but it's maybe an interesting future of would there be any advantage to actually trying to design a quantum memory where you did take advantage of that. And so some of you may recognize that this kind of idea of using one quantum system to control another quantum system, there's a different way of formulating this
35:01
that Seth Lloyd and some others have looked at. I think the main distinction is that we're there, they tend to just sort of take a system, split it into two parts and ask about designing the interaction Hamiltonian. This is a little bit of a different story because we're really assuming that all of the interactions between the Python and the controller are mediated by propagating electromagnetic fields.
35:20
And so it actually makes for a much more experimentally friendly and a more engineering friendly kind of design paradigm, which is much closer to the kinds of things that we're used to dealing with in electrical engineering. Right, so we don't assume that there are any direct Hamiltonian interactions between the controller system and the plant system. Rather, the only thing that's really happening is this kind of funny loop scattering involving coherent optical or maybe even microwave fields.
35:46
So here's a schematic example of what we would call a continuous bit flip quantum error correction system. And so this kind of schematic is meant to be completely analogous to the simple op-amp with the two resistor network that was shown on one of the introductory slides.
36:04
So the items that are actually on this diagram, so there's a Q1, Q2, Q3. So those are meant to be the three qubits of the register. So the logical state in the memory is encoded in an entangled state of those three qubits. As I had earlier mentioned, we assume that each one of those qubits is coupled locally to its own optical cavity.
36:23
And that cavity is there in order to enable this kind of scattering read out of the parity. Now, in addition to those three qubit cavities that form the register, we're also gonna have two devices of a kind that we call a relay. And I'll show you a kind of zoom in or push down into what that looks like in just a second.
36:40
But then all of these things are really kind of cavity QED-based devices. So they have very lined optical input and output ports. And what the red and blue lines show you is really how those input output ports are supposed to be connected, right? So the idea is that if you're a brilliant, advanced, manophotonics engineer, and you understand the basic principles of the cavity QED that goes into the design of each one of these components,
37:01
then it's fairly simple for you to translate this cartoony diagram into an actual schematic for the devices that you would fabricate by lithographically patterning some very thin dielectric wafer. Maybe you then have to do some fancy things about implanting quantum dots or other sorts of impurities like that. But if you could make that sort of thing, right,
37:21
where the connections among the components are realized just by fixed waveguides that you fabricated into this chip, the claim is that once you make such a thing, in order to kind of get this thing to go and do continuous quantum error correction, the only thing that you have to add is you have to power it, right? And so in this case, what that means is that there are three input ports, which really you could draw as two.
37:42
So there's a blue input port all the way, and you're just supposed to inject laser power at a given wavelength into that port. And then there are these two other red input ports marked beta. Obviously those could come out of a beam splitter from a single red input port, but that's a place where you're supposed to inject a different wavelength laser beam. And so in order for this thing to work,
38:00
there's a certain parameter hierarchy that should be respected. So alpha should not be much larger than beta, and beta and alpha should fit in between some other parameters of what actually gets built in the circuit. But a very important thing about this is that you don't have to fine tune their values at all, right? So the overall error correction circuit will work for a very wide range of those actual parameter values. And also, they don't have to be perfectly constant in time.
38:22
You don't have to clock them. You certainly don't need to make them conditional on any signals that are coming out of the device. You really just have to put power in from two lasers. So in that regard, we feel like we get a lot closer to the kind of familiar situation from electrical engineering, where you've just got plus and minus VCC. You just hook up a power supply and the thing goes.
38:41
And so that's really the ideal that we're trying to use in this sort of a design of an autonomous quantum memory. So in order to show you, finally, how we really wrap all of that stuff up into an overall model of how the circuit works,
39:05
the essential idea of it is that once you have defined input-output models for each one of those different components, then we can sort of abstract it to where, say, these boxes that are marked B1, B3, B5, those are beam splitter devices.
39:21
Every beam splitter has, if we just think about unidirectional flow, it has two input ports and two output ports. Those are represented by the left and right circles. Likewise, the devices that I've called relays have four inputs and four outputs, and those are shown right there. The cubic cavities end up having both the scattering input-output ports that are for the parity measurement, and there are also feedback ports
39:42
to drive Raman transition of the atoms. Those are also drawn there. But sort of once you have those individual components, then what you would like to do is build an overall model for the circuit where we consider the interconnections of, say, you take one of the outputs of this beam splitter, and you route it into some specific input in one of the qubit components.
40:01
So once you specify that connection topology, we use this so-called quantum circuit algebra, most recently detailed by John Gove and Matthew James, where you can take those individual components, which are mathematically represented in a certain way by the symbol B1, Q2, 1, Q1, 3, and the connections, the serial connections
40:22
are specified by these little triangles. These box plus symbols indicate something which is kind of like a tensor product thing, right? But you now have a way of understanding how these input-output models need to be connected in order to construct an overall circuit model. And so that's something that we can now do in a relatively straightforward way using developments in quantum optics circuit theory,
40:41
which have really, over the past few years. So as for those individual components, we've already talked about how to model the parity measurement by this cavity QED scattering kind of setup that's drawn in the upper left-hand corner. Feedback operations onto the individual atomic qubits can be implemented by Raman transitions.
41:01
So G and H here are like the logical states for the atoms inside the register qubit atoms. If we want to flip the state of that, we can do that by closing an optical Raman transition. And those Raman transitions are things where they only get, if they're sufficiently detuned from a virtual excited state, then those Raman transitions are only driven
41:21
if both of those different probe beams that are drawn by the red arrows, if they're both present at the same time. And so that gives us kind of an anding capability that one needs in order to turn the syndromes into a specification of which qubits are actually supposed to be flipped. And then the relay is a somewhat complicated kind of thing. It again involves an atom-like emitter or impurity.
41:42
Now it's supposed to be coupled to three distinct cavity modes. But again, you can write down the kind of microscopic description of what that thing is in terms of a cavity QED model. And you can simulate it at that microscopic level and verify that it works reasonably well in accessible parameter regimes. But what's perhaps more important for really describing this overall circuit
42:02
and doing simulations or master equation integrations of the circuit. Now, if you think about it here, if we've got three cavity modes and you end up needing a four level atom description in order to get the microscopic model of the relay, then you're probably talking about a thousand Hilbert space dimensions to really do that in the familiar sort of way.
42:21
But what's been very nice is that we can make use of a limit theorem that was recently derived by Boughton, Van Handel and Silverfarb such that in this small volume limit that I've talked about a couple of times already, which is the natural one for nanophotonics and where you assume that G and Kappa for the cavities both get large at the same time,
42:41
that that thousand dimensional-ish kind of a microscopic model for each relay limits to a very simple model that has a two dimensional internal qubit space and where the ways that external fields interact with that internal state can all be specified by a scattering matrix type thing, which is like the usual sort of scattering matrix
43:00
except the matrix elements are operators, right? So these are projectors onto the G and H states of the relay and these are operators that swap the state of the relay. So having done that, the relays can now be replaced by two dimensional sorts of models rather than thousand dimensional sorts of models and it becomes reasonable to imagine that in building up a circuit model for something like this, we've got two dimensions for each of the qubit cavities
43:22
and we've got two dimensions for each of the relays and so this is now something whose overall dimension is small enough that we can actually do explicit integrations of the thing. We can actually look at the master equation and tell what's going on. On the other hand, we can have some confidence that that's a limit model that really controls the behavior of a true microscopic physical model for such a thing in the frame
43:41
where G and Kappa are both large. That's been a very important kind of modeling and analysis tool that we've brought along in conjunction with doing this work on quantum error correcting codes. So at the end of the day, if we now apply all this fancy limit theorem stuff and apply the quantum circuit algebra, what it will spit out for you at the end of the day
44:01
is an actual master equation for the evolution of this autonomous quantum memory and so what you'll note in it is that here's the specification and so the overall form is the usual sort of master equation, the top left hand equation. Rho T, that's the density matrix as a function of time, that's the density matrix jointly on the internal states
44:20
of the three qubits in the register and of the two relays. It's got the usual Lindblad form, so there's a Hamiltonian H, there's a set of Lindblad operators of which I've here written four and the other three are simply the bit flips that act randomly on the three register qubits. And let's see, so let's actually first look at what the jump operators are.
44:41
Cell one, if we look at this thing, what does that look like? So we've got one plus Z one, Z two, right? So Z one and Z two, those are the Pauli observables for the first and second qubits. Their product is the qubit one, qubit two parity. So when the qubit one, qubit two parity is even, then that thing takes value one and so one plus one is two, so that term is operative
45:01
and so the operator that multiplies that is sigma HG relay one, right? So that says that when the parity of qubits one and two is even, there's a kind of a decay term which tries to decay the state of relay one from the G state into the H state. On the other hand, in L two, we've got the opposite sort of thing where since this is one minus Z one, Z two,
45:21
what that term does is that when the parity of qubits one and two is odd, there's a term that tries to decay the state of relay one from H into G, right? So it really, there's a decay term that tries to force the state of the relay into something that logically reflects the parity of a pair of qubits and you've got the complimentary thing going on in L three and L four for qubits two and three and the state of relay two.
45:44
If we then go back and look and see what's happening in the Hamiltonian, we find that there are terms like projector onto G of relay one times projector onto H of relay two times X one. So that term in the Hamiltonian says, I'm gonna induce a Rabi oscillation to bit flip qubit one, if and only if the states of relay one and two
46:01
are G and H respectively. Second term, we'll try to flip qubit three if the two relay states are H and G and the last term tries to flip the state of qubit two if the relay states are G and G and obviously if the states of the relays are H and H, then there's no feedback applied. Right, so the overall logic of decoding the syndrome table to determine which one of the qubits
46:21
is supposed to be corrected, that's just directly written into what's going on in the Hamiltonian and sort of the action of the probe beams in terms of now driving the relays to correctly diagnose the syndrome that somehow encapsulated in these Lindblad type operators that are giving you a sort of decay. And you know, this, when this, this really,
46:40
so these equations popped out of a kind of 20 page set of calculations that start from really microscopic models of the cavity QED dynamics of all of the components that we're designing into the circuit model. But after applying these limit theorems, this is the thing that just pops out on its own as the dynamics of the quantum error correction circuit in the small volume limit. And it was very nice to see this whole thing come out
47:02
in this very sort of easily interpretable kind of way. And I think, you know, I'm sure, I know that other people have looked at writing down master equations to correspond to something like a quantum error correction but this is, at least as far as we know, the first example of actually microscopically deriving one starting from a completely specified and reasonable
47:22
underlying physical component models. Now, one thing that I think is kind of cute about this is that, you know, since, I mean, we have these things where there are a lot of the terms that are kind of like decay terms, you know, it points out that in classical control theory, you get used to the idea that you use real-time feedback for distinct kinds of purposes.
47:41
So one reason why you use real-time feedback is to accomplish disturbance attenuation. So if there's some disturbances acting on your plant and you wanna suppress those, real-time feedback is the only really powerful way to do that when you're in this kind of Markov limit for the dynamics of the plant versus the correlations of your disturbances. But the other reason why you use real-time feedback is that by doing so, you can actually tailor
48:03
the effective dynamics of your plant. So a classic example of that is if you have something which is a nonlinear oscillator, right? So it's X squared plus X to the fourth, something like that. But if you have a measurement of X as a real function of time, and you can act back on it with an arbitrary force, well, obviously, if you act back on it with a force that looks like negative your measurement
48:22
to the fourth power, you can try to cancel out that nonlinear part of the oscillation, right? So real-time feedback is also used to synthesize dynamics in a certain way. And so what you get here is a funny kind of, I would like to sort of take some time to look at this, but kind of what you've done by these scattering loops,
48:43
right, I mean, we don't have any direct physical interactions between any of the degrees of freedom that are here, right, so the register qubits don't directly interact with each other, they don't directly interact with the relay states. All of those interactions are really carried by this field. But at least when we go over into this strong parameter limit, you find that the overall equations of motion have a kind of a ferromagnetic sort of flavor to them,
49:02
right, and that you have decay terms that are really trying to keep the states of the relays and the registers as correlated as possible, and they're even decayish types of terms. Truly, somehow what you're doing in all of this, and maybe this is just a feature of the bit flip error correction code, you're sort of synthesizing a ferromagnetic interaction and then trying to get the thing to stay cool.
49:20
And using coherent feedback is a way to do that, where those interactions actually get synthesized at the Winblad and Hamiltonian operator kind of level. Okay, so just in the last couple of minutes, let me just mention that, okay, so having written down this overall master equation, you can do numerical integration with a range of different parameter values.
49:41
Here, omega is some single parameter that captures the overall strength of the optical probes that are in the feedback loop, and as that increases from zero up to higher values, you see that the decay of the fidelity of the encoded qubit slows down more and more and more. So another thing which I think is interesting about this
50:01
is you note that the way that the parodies of things and the relay states appear in these Winblad operators, if you have bit flip operations that were acting on the relay state, those would also get corrected by the coherent feedback, because when the parity of qubits one and two is even, it tries to push the relay one state from G to H.
50:23
Now, if the parodies don't change, but some environmental error comes in and accidentally flips the state of the relay, it will try to get pushed back by that same term. So in this feedback, the qubits correct the relays in the same way that the relays correct the qubits. So that's a nice property of the code, but it's about things like propagation losses. So in these sorts of nanophotonic circuits,
50:42
if I'm taking light from one of these devices propagating through a waveguide and trying to inject it into another, obviously the transmission of light through that isn't gonna be perfect, so one wants to have a model that includes propagation losses. It is straightforward, but extremely cumbersome to do that. These are, this is work that's now being done by Gopal Sarma, who's here somewhere in the back,
51:03
of really taking apart the network model, inserting a whole bunch of beam splitters to model the losses, sort of distributed everywhere throughout the circuit, and having done that, one can then go back in and take that composite model that includes the losses and look at the performance of the bit-filled code or say, the phase-flipped code as a function of the increasing loss parameter.
51:23
I should say that in this kind of a circuit, so in this circuit layout, if you just change some things about the polarization of the light and the way that the logical states are defined, for exactly the same kind of atomic level structure, you can implement a field instead of a bit-filled code, if that's what you wanna do, and that gives you the idea that,
51:41
well, you really ought to be able to construct a shore-like code, and so in fact, in a paper from earlier this year, in the New Journal of Physics, we sort of lay out the picture of how you would construct a nine-qubit as a bacon-shore type code, where the actual implementation that we looked at, the only way that it uses the subsystem structure is that it sort of uses the cheap and easy feedback method,
52:01
where it just sort of corrects some particular qubit in each row and column, rather than going back to the exact ones, but you can further make use of the subsystem structure by breaking up the measurements and things like that, so I think all of those basic ideas that come up in the usual world of quantum error correction, they propagate very easily into this continuous-time method.
52:21
So, just as a last comment, this idea of now being able to view quantum error correction as a form of coherent feedback control, I mentioned on a couple of occasions that coherent feedback control is a theme of increasing interest in the quantum control community as a whole, and something that we've been particularly interested in is that if you think about
52:42
the industrial laboratory efforts that are going on in places like HP and IBM, they're really plunging ahead, building nanophotonic systems for doing classical information processing, but if you listen to the kinds of performance goals that they have, they're always talking about trying to get into a regime of addajoule switching energies and picosecond switching times,
53:01
and so what that says to me is addajoules in the optical is a handful of photons, picosecond is a small time compared to the coherence times of things that we know, and so, like it or not, if those are your goals for your classical information processing, you will have to deal with quantum fluctuations in the optical fields that are propagating through your circuit, and, of course, if you wanna play any of the usual tricks that people have
53:21
about sort of taking NAND gates and making them into latches or all that other sorts of classical logical stuff, if you try to push that onto a photonics implementation in this addajoule picosecond world, you will have to model those things quantum optically or you will not get the classical information processing performance, and so a large part of our group's effort, and this is now the DARPA-funded thing
53:40
that I had mentioned at the beginning, is on trying to take coherent feedback control theory for quantum optical systems and to recast it as circuit theory for classical manaphotonics, and so a lot of what that has involved is kind of building a whole system where we can do schematic capture using graphical symbols and using your mouse to connect the inputs and outputs of these symbols,
54:02
doing that using common tools like G-scam, so commercially available or even open source, freeware kinds of schematic capture tools, we can compile that into a sort of a text-based description of what the actual quantum optical circuits are in terms of how the components are connected, and then there's a very large Python code
54:20
that we'll go through and compile that and spit out at the end of the day a completely quantum mechanical model, and so what we're now trying to do is kind of sort of merge these streams of thought where to think about quantum optical circuits for more complex codes with or without propagation losses included, we'll do those calculations by hand, but they're already extremely, extremely cumbersome,
54:40
and so, but any of this methodology that we're building to make quantum optical circuits for classical information processing, they're fully quantum mechanical, they carry all the entanglements and all that, so you can also use them for the quantum information processing, and so, you know, just to finish up, let me emphasize that maybe is the main thing that we like about all this where by taking quantum error correction,
55:01
viewing it as a form of coherent feedback control in nanophotonic circuits, it somehow now appears as one end of a continuous spectrum of things that one can do in the world of nanophotonics or maybe circuit QED, and I think that sort of very simply connects it to very large-scale industrial efforts that are going on, and it maybe helps us see how quantum engineering really is just a kind of perturbative evolution
55:22
of a present-day electrical engineering. Thanks. Thanks, Leo, for introducing us to this nanophotonic circuitry. Are there any questions? Several.
55:44
My question may not be well-formed, so bear with me, but what I'm wondering is how does this QEC coherent feedback control depend on this physical system being coherent? So, for example, H-bar omega being greater than KT, or coherence time is much greater than operation time.
56:03
I guess what I'm getting at is how far can you extend this idea beyond Cavi-QED, perhaps to other physical systems? I mean, I think the general approach is certainly extensible. I mean, really the only, and the main idea that happens here is that we try to take the logical operations that are usually done in decoding the syndrome
56:22
and determining the feedback, and we try to implement that using parts that are the same parts that we use to make the qubits. We try to do that as simply as possible, and we end up with a model that kind of looks like this. Now, obviously, the qubits that are in your register, those things happen. If you actually look at what happens in this sort of operation is that since the feedback in regular quantum error correction
56:42
is completely classical, what you find is that the relay states internally never have to be coherent. And then, you know, the only other place where we really make use of coherence is that the way that the phase shifts in the probe beams are read out is essentially by closing interferometers. So these beam splitters that appear right there just on the input to R1,
57:01
that's sort of an interferometric way of changing the phase shift on the probe beam into routing of the probe power into one of the inputs of the relay or the other. Right, so the whole thing is, in some sense, kind of interferometer, so we do rely a little bit on optical coherence. But otherwise, sort of because the basic ideas of QEC are very classical in terms of the diagnosis and feedback,
57:22
this circuit itself is not particularly coherent as a coherent feedback circuit. Other than that, you can ask and say things, I mean, here I'm going way outside my realm of knowledge, and so this may be a completely stupid assertion, but you could say, if you're gonna do all this feedback coherently, you could rely on coherence's entanglements of the relays, and maybe if you did that,
57:41
you could think about codes where you didn't have to have stabilizer generators that commuted, I don't know, so maybe there's some room for using this kind of setup to generalize a little bit the way that you think about the design of quantum memories. So at the beginning of your talk, you said there weren't going to be any filter functions, but my question is, well, why not?
58:00
I mean, it seems like you have enough tools here to ask the question that you can't usually answer in QEC, how does this work as the speed of the bit flip errors or the noise that leads to the bit flip errors as that spectral density changes? It seems like you could do that analysis pretty readily for this circuit. Your only limitation would be in the dimension
58:22
of the numerical model that you end up with, in that we go to a limit where things are Markovian and effectively in this small volume limit, there are lots of things that happen, the states of the relays change with scattering events, so that limit allows us to get a very numerically compact model, but if you go back to the full model, then you can insert any kind of complex dynamics you want,
58:42
and yeah, exactly, look at how the performance degrades as a function of various kernels of whatever kind. You would then just be, you would have to deal with a model that was dimensionally much more complicated, but you could certainly do it. In the interest of time, I would rather suggest that we have one question and the short answer.
59:06
In figuring out what the right feedback is, you could imagine a wide range of modeling, I mean, in the classical case up to the point where you actually kind of kept a model of the state, exact state of the system at all times
59:21
and figured out the right thing, down to just from your instantaneous measurement result immediately feeding back something and it's a simple function of that. How much variation do you have to do, or how much does simplifying cost you performance?
59:40
Yeah, so the way that the coherent feedback thing is implemented, the logical processing is kept as simple as possible, so we just do something straightforward. If you take this sort of setup where you imagine that the conditional probabilities on the error state are accessible to the controller and you could do anything that you want, you can use the classical framework of stochastic hybrid control to define.
01:00:00
find things like cost functions, and you can do optimizations. And that is described a little bit in a 2010 New Journal of Physics paper, where what you do is you define a continuation region. So you plot the conditional probabilities of three errors. That's now a point that evolves in a three-dimensional space. You can derive surfaces where, when you hit one of those surfaces, that's when you take your control action.
01:00:20
And the locations of those surfaces are determined as a function from cost functions that you specify. So there's room for a lot more complicated kind of stuff. OK. I'm afraid in the interest of time, we have to close here. Thanks again, Hideo, for a nice talk.