Placeholder Image

Subtitles section Play video

  • [MUSIC PLAYING]

  • JOE BARDIN: Welcome to virtual March meeting.

  • Today, my talk is about the control of transmon qubits

  • using a CMOS integrated chip operating

  • at cryogenic temperatures.

  • Outline of my talk is as follows.

  • I'm going to start by explaining how transmons are controlled.

  • I'm really just going to review this.

  • I'll review what transmons are, how we control them,

  • what the considerations in terms of control are.

  • Once we have the basics down, I'll

  • go over how people do this today, what kind of hardware

  • is used, and really importantly, why

  • it's not scalable to future fault tolerant systems.

  • Once I've motivated the work, I'll

  • present the design and implementation

  • of a cryo-CMOS controller followed

  • by experimental characterization.

  • So this is a basic diagram of a transmon qubit.

  • The qubit itself is made up of a nonlinear LC resonator.

  • Here we have, instead of just one Josephson junction

  • replacing the inductor in a parallel LC resonator,

  • we have two.

  • This is a squid, which acts as a flux tunable nonlinear

  • inductor.

  • You can tune the effective value of this inductance

  • through an external bias that threads

  • a flux through the loop.

  • We also have an XY drive port on here,

  • which we can use to couple energy

  • at the resonant frequency of the qubit into the circuit.

  • It turns out if you turn--

  • you cool this down to temperatures low enough, such

  • that thermal energy in the environment

  • is lower than the effective photon of a--

  • or effective temperature of a photon in the resonator,

  • then it behaves quantum mechanically.

  • And its nonlinearity gives us a really nice feature

  • called anharmonicity, which means

  • that the spacing between each of these levels is different.

  • What that means is that, if we want to drive from the 0 to 1

  • state, we want to drive at omega 01.

  • If we want to go from 1 to 2 or back, we drive at omega 1, 2,

  • and so forth.

  • And all these are different frequencies.

  • The more nonlinear the qubit is, the more--

  • the bigger the differences between each

  • of these spacings, and the easier it

  • is to address an individual spacing.

  • So if we can constrain our drive signals to just omega 01,

  • then we can just address the 01 subsystem,

  • and it behaves as an ideal 2-level qubit.

  • So the transmon qubit is this circuit,

  • and when we operate it, we typically want to be in just

  • a 01 subspace, which means our drive signal at the RF port

  • needs to be bandlimited, such that we don't hit omega 12.

  • To put some numbers on this, typical frequencies for omega

  • 01 are 4 to 8 gigahertz, which means that we really need

  • to cool to the 10 millikelvin range so that we have

  • sufficiently suppressed thermal noise in the resonator.

  • And our anharmonicity, or difference between omega 01

  • and omega 12 expressed in hertz is about 150 to 350 megahertz.

  • As I'll mention shortly, this is an engineerable parameter,

  • as you see here based on the C in the resonator.

  • If we write the Hamiltonian system in the lab frame,

  • we find we get this form.

  • You have two terms.

  • First you have, this sigma Z term,

  • which is describing a natural rotation

  • about the negative z-axis at the qubit frequency.

  • And then you have a drive term due to this--

  • this drive source here.

  • And that causes a rotation around sigma y.

  • If you look at what's going on, you

  • see that this term is causing it to rotate

  • around the negative z-axis.

  • Whereas this term is causing a y rotation.

  • We usually like to think about it not in the lab frame,

  • but in the rotating frame.

  • So if we write the rotating wave approximation,

  • we get a slightly different expression,

  • but we no longer have the sigma z rotation,

  • and things are easier to think about.

  • So if we drive at omega 01 with sine omega 01t and a phase pi

  • minus phi d, where this as a controlled variable and some

  • envelope of function, we find that the Hamiltonian looks like

  • this.

  • And we have a sigma x and sigma y term,

  • and their weights are dependent on the phase of this carrier

  • signal.

  • So if we control the carrier signal,

  • we control the rotation about sigma x and sigma y,

  • or the rotation about some axis, which

  • axis the vector we're rotating about is.

  • It's going to be in the x, y plane,

  • but we can control where it lies.

  • And the amount of rotation is determined by the envelope.

  • So we can set this envelope to determine how far we rotate.

  • And we can set the phase, as I mentioned before,

  • to set which axis we rotate about.

  • So basically, when we design our control pulses,

  • we want to engineer these things to get what we want.

  • So how do we pick the envelope?

  • Well, there are a couple of considerations.

  • We have a finite coherence time.

  • For transmon qubits, this might be 50 microseconds.

  • It might be shorter, depending on what the exact circuit is,

  • but we can engineer this anharmonicity by choosing c.

  • Larger anharmonicity means we can have more bandwidth

  • in our pulses, which means we can make them quicker.

  • So we'd want smaller c to do fast gates.

  • On the other hand, the dephasing time, T2,

  • is determined by the frequency fluctuations of the qubit,

  • and we want to be insensitive to charge noise

  • so that, if we move around--

  • if our charge moves, then the frequency doesn't jitter and--

  • causing dephasing.

  • So it turns out what the beauty of the transmon

  • is, if you put a big capacitance,

  • you really desensitize yourself to the charge.

  • You really flatten these curves out,

  • and so charge noise doesn't hurt you as bad.

  • So there's these conflicting design criteria.

  • You want a small capacitor for nonlinearity.

  • You want a big capacitor for large T2.

  • Because of this, we typically end up

  • with 150 to 350 megahertz range for our anharmonicity,

  • which gives us single qubit gate times in 10 to 30 nanoseconds

  • range.

  • And we have coherence times typically

  • 30 to 100 microseconds.

  • So how do we actually shape the pulses?

  • Well, we want to avoid the omega 12 transition.

  • We want the pulse to be as quick as possible.

  • If were to use rectangular pulse,

  • we'd get this sink side lobes.

  • And we-- it doesn't roll off very fast.

  • We want to do something more clever than that.

  • Gaussian pulses have been quite popular for a long time.

  • You usually have to truncate them or have some limiting

  • function you multiply them with so

  • that they don't go on for all of infinity,

  • because a Gaussian never really ends.

  • Another kind of convenient pulse that has well-defined start

  • and stop sign--

  • start and stop time is the raised cosine you can see here.

  • And you can see the spectrum of all these different pulses.

  • So the Gaussian is without a limiting function,

  • so it would pick up some side lobes also,

  • but you can see both the Gaussian

  • and raised cosine roll off much quicker and allow us to--

  • because of that, we can do much quicker pulses

  • than if we were just using rectangular shaping,

  • as you might do if you were driving, say, a spin qubit.

  • So in this work, we'll use raised cosine,

  • but I do want to acknowledge Gaussian, as well.

  • Is this all we want?

  • Even with this raised cosine, we'd

  • still like to make the pulses as short as possible.

  • So people like to do things like second order shaping.

  • In addition, as you drive the qubit, it's a nonlinear thing.

  • Its frequency changes.

  • So depending on, if you want to drive a pi pulse, 180 degree

  • rotation, or a pi over 2 pulse, which is typically

  • half the amplitude, you might need

  • to drive at a different frequency for the two.

  • So there's a stark shift that you might need to compensate.

  • So to get rid of--

  • so one thing that's used is drag.

  • Drag-- we put in a derivative term that's weighted.

  • This is in quadrature if you want to think in the microwave

  • terms.

  • So you have a sine and a cosine carrier term.

  • And if you do it right, with drag of 1

  • you get a notch at some frequency that you can set.

  • If you set that at omega 12, you can avoid the omega 12

  • transition by adding this extra modulation tone.

  • And typically there is-- you also

  • want to do an amplitude dependent offset

  • to compensate the stark shift.

  • When you see the work we've done,

  • we haven't done this more advanced shaping, but we'll--

  • it's something for future work.

  • So I wanted to introduce it anyways.

  • So a couple practical issues--

  • how strong should these pulses be?

  • I could go through all this math,

  • but essentially you're going to end up integrating the envelope

  • amplitude, and you're going to find, when you get out, some--

  • for a raised cosine pulse, some level.

  • And it's typically, depending on if you're

  • raised cosine, Gaussian, other types here,

  • or rectangular, you're somewhere in the 50 to 500

  • microvolt pulse amplitude at the port of a qubit.

  • Now, we need to really lightly couple

  • the qubit, because we don't want it

  • to cohere the qubit through coupling to our 50 ohm source.

  • So you're typically using [INAUDIBLE] farrad

  • type capacitor to couple.

  • So you're very weakly coupled, and only a small fraction

  • of the energy that's available at that port makes it.

  • Just to put some numbers, this is maybe

  • negative 65 DBM, negative 70 DBM of power

  • available at that port, but it's attenuated by about another 30

  • dB before you get to the qubit.

  • Sorry, another 60 dB, not 30.

  • Another important thing is how much noise

  • can there be on the drive line?

  • Noise here will cause up down transitions,

  • which will hurt your coherence.

  • We really don't want this.

  • So you can write an expression.

  • I've written it in a way that looks

  • nice to microwave engineers, where the rate is

  • the bandwidth over which you couple times

  • the ratio of the effective temperature of this resistor,

  • assuming it's going to put out white noise, thermal noise,

  • to the temperature of a photon at the qubit frequency.

  • That's-- at 1 gigahertz, a photon will be 50 millikelvin.

  • At 5 gigahertz, it would be 250 millikelvin.

  • I already said these.

  • We can plug in for this, the delta omega.

  • It's the ratio of the qubit frequency,

  • the omega 01 to the effective q due to the drive circuit.

  • So if the only thing dequeueing the qubit

  • were the drive circuit, that would be this value.

  • And this is-- inversely, this is 1 over the t1 due to the drive

  • circuit.

  • We typically set that to be about a millisecond, which

  • corresponds to a q of about 40 million

  • for a 5 gigahertz qubit.

  • You can do some simplification, and if you

  • were to set this 1 over the rate of transition,

  • so effectively how much your qubit de-coheres

  • due to the noise on this line, and make that equivalent to how

  • much the qubit relaxes due to damping by this resistor,

  • if you make those two things equal,

  • you find the amount of noise you can take on the driveline

  • is one photon worth of noise.

  • That's independent of the coupling,

  • so it's an easy thing to remember--

  • is that we really want to have thermal noise on here

  • equal or less than the equivalent photon energy.

  • We cool these things to 10 millikelvin

  • so we can take a little bit more noise than just the noise--

  • the thermal noise of the attenuator-- actually,

  • quite a bit more, because it's exponentially

  • suppressed with cooling, but not that much more.

  • So that's the basics.

  • How is it done today?

  • What kind of hardware do we use, and why do we

  • want a different approach?

  • This is a block diagram of the basic configuration

  • of Google's electronics from a high picture.

  • I've highlighted the x, y drive, because that's

  • what this talk is about.

  • You can see that the one channel--

  • this is driving one qubit--

  • has two decks.

  • We use in phase and quadrature modulation

  • due to the single side band mixing.

  • So we create two side bands.

  • We up convert it, filter, attenuate quite a bit.

  • Let's see, 43 dB of attenuation, so roughly

  • the ratio of temperature.

  • Actually, not quite, but--

  • and then a couple of the qubit.

  • So if we're doing a big experiment,

  • I would say, at least that where we are right now,

  • this is the right way to do things.

  • My philosophy is that we should do things brute force

  • until we can't, because getting the qubit physics sorted out

  • and everything is more important than integrating

  • electronics and doing the electronics in the most

  • scalable manner when we're just carrying out basic experiments.

  • So I would say this is the right way to do a small scale

  • experiment, like 100 qubits.

  • But we still require--

  • so this is 72 qubit.

  • It's not the quantum supremacy chip,

  • but it's another chip that we're measuring before.

  • 72 qubits requires 240 AWGs, 84 up converters,

  • 12 down converters, 24 high speed ADCs,

  • 160 coaxes to the cryostat, 168 coaxes down superconducting.

  • These are not cheap.

  • There was an article in "Tech Review" a couple months ago

  • about this shortage of these.

  • And something that I think is really crazy

  • is it takes 3 terabits per second.

  • Now, these are narrowband pulses.

  • They're not broadband.

  • There's not that much information in the pulses,

  • and yet we take 3 terabits a second to continuously drag

  • this thing.

  • So for small scale demo, I think this is the right way to do it,

  • but we need to think about other things as we're moving forward.

  • What is the ultimate end game?

  • Well, this is essentially where we are now.

  • This is a 72 cubic processor.

  • We're just on the cusp of being able to do things you can't

  • do with a classical computer.

  • In fact, just within the last couple months.

  • But our long term goal is to be over here.

  • And at least if we're using transmon qubits

  • with their associated error rates,

  • and we want to do something like surface code,

  • we're going to need a million of these qubits.

  • And we need to find some way to make this connection.

  • So how are we going to get from here to here

  • in terms of control?

  • So this is where we are.

  • This is-- I'm going to use 54 qubits as a number,

  • and you can see this isn't even all the cables you'd have.

  • If we want to scale to a million or so using this,

  • what does it look like?

  • Well, this is one.

  • If we scale to--

  • you could see all the cables in here.

  • Not much extra room to put stuff if we

  • do things exactly the same.

  • So if we want to go to 540, I'm just

  • making a point here how much we-- how far we need to go.

  • 8,000, 13,800, a million--

  • that's how far we are in terms of building systems

  • from where we want to go.

  • Clearly we have to do something different.

  • So how do we do things today?

  • We have classical computer, high speed digital bus--

  • that's where that 3 terabits a second was going.

  • We have racks of equipment, coax cables going to the cryostat

  • down to the chip.

  • This is good for 72.

  • It's probably good for 500.

  • It might be good for 1,000, but it's not good for a million.

  • One approach-- and this is not the only approach

  • is to take this part and bring it a lot closer to the qubits.

  • And then we have to figure out how, say,

  • if we put it at 4 kelvin, we have

  • to figure out how to get down to the qubits,

  • but we might be able to use superconductors for that.

  • At 4 Kelvin, we can get quite a bit cooling capacity.

  • With a standard cold head, you can get a watt and a half.

  • If you do something closer to what CERN does,

  • you can get kilowatts.

  • So it's not that outlandish to think

  • about cooling large arrays, but we need to make these low power

  • and scalable.

  • And then we need some really reduced

  • data set going to the classical computer,

  • and all the error correction layers, and so forth.

  • So here we're thinking about how can we simplify x, y control,

  • and before showing architecture--

  • the architecture we've used, I want to make a point--

  • is that this is really a brute force approach.

  • We're using high speed DACs to generate narrowband signals.

  • And these DACs, if you look at the data sheets,

  • are able to generate-- this is an example.

  • It's a little bit higher speed DAC than what we're using,

  • but it's just one that's available from analog devices.

  • And this is an example of a spectrum from basically

  • DC to 900 megahertz, where they populate it with 157

  • modulated tones, and they left a dead band in the middle.

  • Now, if you're working in communications,

  • this is important, because you don't

  • want these different signals to have inter modulation

  • products with each other and fill in this space, which

  • would give interference if you were trying

  • to use that gap for a signal.

  • So they make these DACs really high performance

  • to be able to do things like that,

  • because that's really the driving

  • market for a lot of these DACs in terms of development.

  • The cost is that they're very power hungry,

  • and they don't optimize things like data rates and so forth.

  • So it can do this, but we just want to do this.

  • We just want to have a nicely shaped spectrum

  • that we can control.

  • And I would say that this is really overkill,

  • and if we want to have scalable systems,

  • we need to find some other way to do it.

  • And this talk is really-- the work

  • we're going to show is really a first step.

  • So what were our goals here?

  • Well, long term, we have a set of goals here,

  • and then we have some goals for this initial work.

  • And we really relax the specs a bit

  • because we've designed this controller without models

  • to figure out how the transistors are

  • going to work cold.

  • So we had some headroom for that.

  • So for our initial work, we want to work at about 3 kelvin.

  • We want to be in a couple milliwatt power consumption

  • range, which is about three orders of magnitude

  • lower than that chip I showed on the previous slide.

  • We'd like to operate over a broad frequency range.

  • It could be more fine tuned for a more permanent solution.

  • We'd like to have about 10 milliamps--

  • or millivolts of amplitude so that we have margin,

  • because we're designing it without real good models,

  • and we might have less in the end if we don't over design.

  • We'd like to be able to pick a couple well-defined wave forms

  • and play them back rather than sending a continuous stream.

  • So we pick four bits, or 16 wave forms.

  • It'll be able to operate in a 10 to 30

  • nanoseconds pulse duration, not hit the 1 to 2 transition,

  • and have performance that is able to hit the fidelities

  • needed for error correction.

  • So just a bit of a spoiler is that we weren't actually

  • able to characterize these last two,

  • and that's work in progress.

  • So first, I'd like to explain that the approach we took

  • to wave from generation.

  • So it's much different than the approach

  • that you would take if you were just making a DAC.

  • So basically, what we realized is

  • that, if we don't try and do things like drag,

  • we just need a symmetric envelope.

  • Raised cosine or Gaussian-- they're both symmetric.

  • So what we did was we built an array

  • of programmable current sources, and then

  • have the appropriate enabling functions

  • to create this kind of wedding cake shaped current wave form.

  • And so we can program the amplitudes and so forth.

  • And if we filter this, we get rid of the steps,

  • and it looks like a nice, smooth, symmetric envelope.

  • So this gives us the e of t.

  • We then need to put it on a carrier.

  • So we have a mixer to do that.

  • We have an off chip--

  • a low signal and a limiting amplifier to drive the mixer.

  • And then we have some filtering to give

  • us-- to get rid of the harmonics and end up

  • with a nice modulated signal.

  • So this is all fine and good.

  • We could control-- but we don't have phase control here.

  • So we need to add another quadrature

  • to get phase control so that we can do vector modulation--

  • sine plus cosine.

  • If you weight the two, you can give an arbitrary carrier

  • phase.

  • And if we don't do anything else,

  • if we just have a quadrature, we only get 90 degrees.

  • So we have to add a polarity switch

  • so that we can do plus and minus in each quadrature

  • to get the full 360.

  • So that's the full picture here.

  • We generate the quadrature carriers

  • off chip for simplicity, but that can

  • be put on chip in the future.

  • So this is the part I already described.

  • In addition, we have this wave form memory

  • that can store 16 different wave form configurations.

  • And then we have four select lines to pick them,

  • and a trigger signal to enable a pulse.

  • So I'll go quickly.

  • This is not a circuits conference,

  • so I won't spend too much time on circuits,

  • but there's a state machine to generate those pulse wave

  • forms.

  • That just turns on the current sources.

  • Turns this one on, and this, this, this,

  • then goes backwards down the current sources,

  • so you get an increasing pulse.

  • This has a nice feature, doing it this way,

  • is that if we just try to change-- take one of these

  • and use it to make it, and turn it up,

  • and up, and up, then back down, we

  • might have issues where we're non-monotonic.

  • That is, if we set it, say, halfway to full scale

  • then move up, it might actually move down because of things

  • that go wrong when you cool.

  • By doing this kind of thermometer

  • turning on like this, then turning back down,

  • we get guaranteed monotonicity, which is nice in the pulse.

  • Each of these current sources has

  • 8 bits of control, which is a little less than the 14

  • bits that are typically used in a DAC,

  • but we have enough degrees of freedom

  • that we can make a wide range of wave forms

  • to compensate for that.

  • After creating the staircase current,

  • we modulate it on to a carrier.

  • We want to be very careful, because we're

  • trying to get as low power as possible.

  • We want to be very careful to not dissipate a lot of power

  • on the LOs.

  • So this-- we have an amplification chain

  • that is really optimized for power consumption

  • to dissipate something like 100, 200 microwatts per channel.

  • There's a tunable balun and a differential stage.

  • This is made with what are called standard cells mostly,

  • and then there's a mixer.

  • There's that polarity switch to switch which way currents went

  • through the mixer.

  • So currently the route--

  • let's say polarity is high.

  • It'll go this way, and then say like this--

  • back down to here, or it'll go the other way,

  • depending on how the polarity switches are set.

  • And then we couple out and combine in the current domain

  • at the output.

  • The chip was made a 28 nanometer CMOS process.

  • You can see the critical things, the transformers,

  • The DACs are quite small.

  • In fact, this chip is-- it could be a lot smaller.

  • It's bond pad limited.

  • That is, we're limited by I/O, not by the chip periphery.

  • All this is empty.

  • This is more or less empty.

  • We packaged it.

  • You can see it's mounted, and I cut out

  • on a printed circuit board to keep the RF lines really short.

  • The clock's coming over here, and then there

  • is digital programming supplies coming off the sides.

  • It's matched to 100 ohms, so we have a Klopfenstein taper

  • transforming that to the output.

  • The yellow signals come in here and here.

  • As you can see, that's pretty tight,

  • and there might be some coupling from here

  • to here, and here to here.

  • We're driving the qubit on resonance,

  • so that could be a problem.

  • So we need to take care of that externally for this chip.

  • In the future, you could cancel that out on chip, actually.

  • So we packaged it.

  • Tested it first at room temperature.

  • This is an example where we're driving

  • the qubit with an RF of 5.6--

  • or the chip with an RF of 5.6 gigahertz, negative 10 DBMs,

  • so 100 microwatt of RF signal.

  • Clock at 2 gigahertz and negative 20 DBM clock signal.

  • So this is going into the quadrature hybrid external.

  • This is going into an external balun.

  • So any losses haven't been taken out.

  • And you can see this is going through the 16 different wave

  • forms.

  • These are just kind of arbitrarily wave forms,

  • like stepping here, and I think one of these is Gaussian.

  • One is raised cosine, and so forth.

  • So we could get wave forms like this up to eight gigahertz RF,

  • even beyond a little bit, and with up to 3 gigahertz clock.

  • So once we tested it at room temperature,

  • we want to test cold.

  • This is the basic setup for how the chip was mounted.

  • We have-- in the Google software back end,

  • we have some interfaces to the chip.

  • We used digital AWGs, so just putting

  • out switching wave forms to connect to the trigger

  • and select.

  • We use a microprocessor to send the SPI to program the chip.

  • And then we clock it with a CW source

  • and provide the carrier with another CW source

  • so that the carrier splits here, and I'll

  • explain why in a second.

  • So at the output of the chip, we have two couplers,

  • and I'll explain the function of these momentarily.

  • Then it goes to a 20 dB pad.

  • We had a little too much power, and so we had this.

  • Then we have another 20 dB cold so

  • that we reduce the thermal noise,

  • because 3 kelvin, of course, is too much.

  • So these couplers are used.

  • The second one is so that we can couple a signal out

  • to monitor at room temperature, which is quite useful,

  • to make sure the chip is working as expected.

  • Then the other one--

  • we have a vector modulator.

  • We go and recombine, and that's to cancel out any LO leakage

  • so that we're not driving Rabi oscillations unintentionally.

  • We also hooked up the standard qubit electronics

  • through this path so that we could do baseline measurements.

  • Finally, we completed the setup with the z control,

  • frequency control the qubit.

  • And a readout chain so that we could make measurements.

  • So once we got this all set up, the first thing we wanted to do

  • is make sure that LO leakage, which we expected to happen

  • and would drive Rabi oscillations, is negligible.

  • Well, first, we looked at the wave forms at the monitor port.

  • You see that you don't get that much information from that,

  • because we have coupling, and it's

  • weak signals to start with.

  • You don't have much signal to noise,

  • but these are typical signals that would

  • be using a gate operation.

  • So that's the first thing to look at.

  • Next, we looked at feed through cancellation.

  • So canceling out those Rabi oscillations

  • that would happen because of LO feed through.

  • So the way we did this was we first reset

  • the qubit to the ground state.

  • Then we waited for a certain amount of time

  • and made a readout pulse--

  • applied a read out pulse and measured the state.

  • We varied this delay so that we could trace out

  • any kind of Rabi oscillations.

  • And before we applied any cancellation,

  • we saw this kind of chevron curve.

  • And so for this, the qubit was set about here

  • as the qubit frequency.

  • And you can see clear Rabi oscillations, so something

  • like a period of about 300 nanoseconds, which

  • is pretty quick.

  • So this is kind of really not desirable.

  • It would really mess our experiments up.

  • So we applied-- so we play with the vector modulator,

  • and we're able to [INAUDIBLE] all this out.

  • You can see now this timescale is 500 nanoseconds.

  • This is 20 microseconds, which is longer than the coherence

  • time of the qubit.

  • And you see really negligible one state population

  • at the end, something like 4%.

  • So the cancellation worked, and this was actually

  • stable over the course of days.

  • So it's practical.

  • And as I mentioned, you could just add another channel.

  • We have a vector modulator.

  • You could just add another channel of control

  • to put this on a chip.

  • Once we cancelled out the LO feed through,

  • we did Rabi experiments.

  • So where we just applied an x pulse of varying amplitude.

  • So we're doing a Rabi amplitude experiment, then a read out

  • pulse.

  • What you'd expect from this, of course,

  • is sinusoidal oscillations, and what

  • we saw when we just swept using the raw DAC

  • codes was something like this, which really doesn't look nice.

  • So for this, we were sweeping the overall envelope amplitude,

  • which is controlled by a current source, which turned out

  • to be non-monotonic.

  • So the reason you see all these wiggles is not

  • because the measurement was noisy,

  • but actually because the DAC was not increasing linearly.

  • It was going up and down.

  • And so what we did was we used a spectrum analyzer

  • and measured the power at the monitor port

  • to calibrate this axis.

  • And once we did that, you can see all of a sudden

  • it really cleaned things up.

  • We view this as OK.

  • We have to do calibration in a system like this anyways,

  • and what really matters is you can

  • find a point, say, right here.

  • So this experiment kind of showed

  • that we can control the envelope amplitude.

  • We haven't said anything about phase,

  • so we did another experiment that's similar to a--

  • that helps bring out the phase.

  • So what we did here was we reset the qubit,

  • then applied three pulses.

  • So these are x pulses that-- with varying amplitude.

  • Then we applied a pi over 2 pulse around--

  • with varying phase.

  • And then we read it out in the end.

  • And if you simulate and figure out exactly what should happen,

  • the probability of finding a qubit in the zero state

  • at the end looks something like this, where

  • you get this-- these peaks.

  • So we then ran the experiment with standard and our hardware,

  • and found--

  • this is what we got at the standard hardware.

  • It looks almost identical to that last plot.

  • Ours was a little more fuzzy.

  • We attribute this to the fact that we didn't calibrate

  • the amplitude for this--

  • of the pulses.

  • But nonetheless, the general shape is still there,

  • and the peaks are about the same between the two curves.

  • So this-- we view as showing that we have coherent control.

  • If you look kind of more proof of coherent control

  • is that, if you look at the residuals

  • between the ideal curve and what we measured,

  • this is standard this is the CMOS chip.

  • And you can see there's really structure in here.

  • That is, there's this bright part here,

  • this dark part here, which is kind of indicative

  • that we could calibrate it out.

  • Then we measure two state population.

  • This is to characterize, do we have

  • more bandwidth than we're expecting

  • or something like that.

  • Are we driving two state?

  • What we did for this was applied a bunch of pi

  • pulses, and at the end measured the probability

  • of being in a two state.

  • We swept the pulse duration from 70 nanoseconds down

  • to about 6 nanoseconds.

  • And we saw, as expected, not much two state population

  • until we got really short pulses.

  • So this is doing about what we'd expect.

  • Finally, we want to make sure we weren't

  • blasting the qubit with noise.

  • That's a concern, given that we have active current sources.

  • And we so we measured T1, and we got almost identical

  • curves within the measurement error for the standard

  • and custom hardware.

  • So a comparison is shown here.

  • Really the critical things are that our chip

  • was less than 2 milliwatts.

  • The standard approach is a watt.

  • 2 milliwatts is even getting close to where

  • you can think about cooling down large numbers of these.

  • The data rate required to control

  • the chip-- we had to send those four control lines.

  • We had to send a trigger, so it all

  • adds up to about half a gigabit per second.

  • It's about 50 times lower than the standard solution,

  • although you can make it a lot lower just

  • by putting a sequencer on chip without much extra power.

  • So in summary, if we're going to build big systems,

  • we're going to need something like this.

  • This isn't the only way to do it,

  • but cryogenically cooled controllers is one option.

  • We've demonstrated one with two milliwatts of power,

  • or actually less than that.

  • In the future, we need to--

  • if we're going to make more of these,

  • we really need a random--

  • perform randomized benchmarking and really quantify

  • the actual fidelities we can achieve.

  • And if people want more information,

  • there's an open access paper with all the details.

  • And the link is here.

  • So if you want information, pause it.

  • I'd like to end with just a picture of the team.

  • A lot of people contributed to this work

  • through the measurements or the hardware, software stack,

  • and so forth.

  • So I'd like to acknowledge the team.

  • All right, thank you.

  • [MUSIC PLAYING]

[MUSIC PLAYING]

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it