JOVANA
Library Glossary Getting Started Three Levels Fields How it works Mission
Join the mission
All guides

Controlling and Multiplexing

A qubit only does what you tell it, and you tell it with carefully shaped microwave pulses. Here is how those pulses are built, why their shape matters, and the clever trick that lets one wire read out many qubits at once.

A gate is a shaped pulse

A superconducting qubit has a transition frequency — usually somewhere around 5 gigahertz, the same band as Wi-Fi and radar. To flip it or rotate it, you send in a burst of microwaves tuned to exactly that frequency. That burst is a microwave control pulse, and a single logic gate is nothing more than one such pulse, shaped just so. Make the pulse last a certain length and the qubit rotates a quarter turn; twice as long, a half turn — a full bit-flip.

The pulse is born at room temperature. An arbitrary waveform generator (AWG) — really just a very fast, very precise digital-to-analog box — plays out two slowly varying voltage shapes called I and Q. An IQ mixer then rides those slow shapes up onto a clean 5 GHz carrier tone, the way a radio station stamps music onto a carrier wave. The result is a microwave pulse whose amplitude, timing, and phase you control to many decimal places.

That room-temperature pulse is far too loud. Sent straight in, its own thermal noise would drown the qubit. So on the way down through the dilution refrigerator the signal passes through stages of cryogenic attenuation — deliberate, cold dampers that throw away most of the power and, crucially, most of the room's heat with it. What finally reaches the chip is a faint, clean whisper at exactly the right frequency.

DRAG: the pulse that does not wake the third level

Here is an awkward truth about a transmon: it is not really a two-level system. Above the |0> and |1> states you actually use, there sits a |2> state, and a few more above that. The whole reason a transmon works as a qubit is its anharmonicity — the |1>-to-|2> step is at a slightly different frequency than the |0>-to-|1> step you want to drive. But 'slightly' is the problem. A short, sharp pulse is not a single pure tone; it is a small smear of frequencies, and the edge of that smear can reach up and accidentally excite |2>. That stray excitation is called leakage, and leaked population is information that has quietly fallen out of your computer.

The fix is a beautifully simple idea called DRAG (Derivative Removal by Adiabatic Gate). Alongside the main pulse on the I channel, you add a second, smaller pulse on the Q channel — shaped like the derivative (the slope) of the first. This companion is tuned to push the |2> excitation back exactly as fast as the main pulse stirs it up, so the two cancel. You get the rotation you wanted on |0>-|1> and leave |2> untouched.

Pulse envelopes (amplitude vs time, not to scale):

  I channel  (main drive, a smooth bell):

        .-''-.
      .'      '.
     /          \
  __/            \__   time -->

  Q channel  (DRAG correction = slope of I):

        _.-.
      .'    `.        the up-then-down wiggle
  __.'        `.__    is the derivative of the
                `-'   bell above

  Together: rotate 0<->1, and the |2> leakage
  stirred up by the rising edge is undone by
  the falling edge.
Top: the main drive on I, a smooth bell shape. Middle: the smaller DRAG pulse on Q, shaped like the bell's slope. Together they rotate the qubit while cancelling leakage to the |2> level.

Reading many qubits down one wire

Controlling qubits is only half the job; you also have to read them out, and reading is where wiring gets brutal. If every qubit needed its own dedicated output line running all the way up and out of the cold fridge, a chip with a few hundred qubits would need a forest of coaxial cables — each one a pipe for heat. This is the famous wiring bottleneck, and it is one of the most concrete reasons today's machines stay small.

The escape is frequency multiplexing. Each qubit gets its own little readout resonator, and crucially, every resonator is built to ring at a slightly different frequency. You hang a whole row of them on one shared output line. To read the whole row, you send in a single pulse that contains all their frequencies at once — a small chord — and listen to how the chord comes back. Each note returns shifted in a way that tells you whether its qubit was 0 or 1. One wire, many answers.

Multiplexed readout: many resonators, one line

  qubit A --[ resonator @ 7.10 GHz ]--+
  qubit B --[ resonator @ 7.25 GHz ]--+--- one shared
  qubit C --[ resonator @ 7.40 GHz ]--+    output line
  qubit D --[ resonator @ 7.55 GHz ]--+      |
                                             v
            send ONE pulse = sum of all 4 tones
            listen: each tone comes back shifted
            -> read A, B, C, D in a single shot

  The faint returning chord is too weak to measure
  directly, so it is boosted first by a quantum-
  limited amplifier (a JPA or TWPA) at the cold stage.
Four qubits, four resonators at different frequencies, one shared output line. A single multi-tone pulse reads all four at once; a cold amplifier boosts the faint return.

The chord that comes back is fantastically weak — a handful of microwave photons. Before it can survive the long, lossy climb back up to room-temperature electronics, it is boosted at the cold stage by a near-noiseless amplifier such as a Josephson parametric amplifier or a travelling-wave parametric amplifier. Only then does the warm electronics digitize each note and decide each qubit's answer.

Honest limits, and where it is heading

Multiplexing genuinely helps, but it does not make the wiring problem disappear — it just rearranges it. You still need control lines going down (multiplexing readout does not multiplex the drives), and you can only stack so many resonator frequencies in a band before two of them sit too close and their answers blur together. That crowding of readout frequencies is a cousin of the frequency crowding that already haunts the qubits themselves.

  1. A pulse is composed in software, played out by a room-temperature AWG as I and Q shapes, and mixed up onto a microwave carrier.
  2. It travels down through the fridge, attenuated stage by stage so the room's heat is stripped away before it reaches the chip.
  3. DRAG shaping lets each gate be fast without leaking population up into the |2> state.
  4. For readout, one multi-tone pulse interrogates many resonators on a shared line; a cold amplifier rescues the faint reply.

The promising direction is to move the electronics closer to the cold. Today's racks of room-temperature AWGs and digitizers do not scale to thousands of qubits — there are simply not enough cable feedthroughs or cooling budget. The hope is cryo-CMOS: ordinary silicon control chips redesigned to run inside the fridge, generating and reading pulses right next to the qubits. It is real and progressing, but still early — every milliwatt it dissipates eats into a thermal budget measured in microwatts. None of this is solved, and that is exactly the work.