Chapter 29: Quantum Computing Systems: Cryogenics, Control Electronics, Calibration, and What It Takes to Run a Quantum Computer

Learning Objectives

After completing this chapter, you will be able to:

• Describe the architecture of a dilution refrigerator and explain why millikelvin temperatures are required for superconducting and spin qubits.
• Trace the signal path from room-temperature arbitrary waveform generators through cryogenic filtering and attenuation to the qubit chip.
• Explain the quantum–classical interface: how digital instructions become analog microwave pulses and how measurement results are digitized and processed.
• Perform standard qubit calibration experiments (Rabi, Ramsey, $T_1$, $T_2$) and interpret their results.
• Understand the full quantum computing stack, from user-level quantum programs to physical qubit operations, including automated calibration pipelines.
• Calculate thermal noise budgets, design attenuation chains, and estimate system-level error contributions.
• Evaluate the cost, power, and infrastructure requirements for quantum data centers.

29.1 The Cryogenic Stack: Dilution Refrigerators

Why Do We Need Millikelvin Temperatures?

Superconducting qubits operate at transition frequencies $\omega_q/2\pi \sim 4$–$6\ \text{GHz}$, corresponding to an energy $E_{01} = \hbar\omega_q \approx k_B \times (0.2\text{--}0.3\text{ K})$. To ensure that thermal excitations do not populate the $|1\rangle$ state, the operating temperature $T$ must satisfy:

$$k_B T \ll \hbar\omega_q \quad \Rightarrow \quad T \ll 200\text{--}300\ \text{mK}$$

The thermal population of $|1\rangle$ is:

$$P_{|1\rangle}^{\text{thermal}} = \frac{1}{1 + e^{\hbar\omega_q/k_B T}} \approx e^{-\hbar\omega_q/k_B T} \quad (\text{for } k_B T \ll \hbar\omega_q)$$

At $T = 15\ \text{mK}$ (typical base temperature of a dilution refrigerator), $P_{|1\rangle}^{\text{thermal}} \approx e^{-(5\text{ GHz})/(0.3\text{ GHz})} \approx 6 \times 10^{-8}$ — negligible for quantum computation. At $T = 4\ \text{K}$ (liquid helium temperature), $P_{|1\rangle}^{\text{thermal}} \approx 0.06$ — unacceptable.

Common Misconception: "Quantum computers need to be cold because quantum effects only happen at low temperatures."

The millikelvin temperature is needed not because quantum effects require cold — quantum mechanics operates at all temperatures — but because thermal photons at higher temperatures create noise that overwhelms the qubit's energy splitting. A transmon qubit with $\omega_q/2\pi = 5\ \text{GHz}$ is a two-level system with energy gap $\hbar\omega_q/k_B \approx 240\ \text{mK}$. At room temperature ($300\ \text{K}$), the thermal energy $k_B \times 300\ \text{K} \approx 6.2\ \text{THz}$ is 25× larger than the qubit gap — the qubit would be completely thermally saturated. The cold environment ensures the qubit sits in its ground state, ready for coherent manipulation. Noise is the enemy — temperature is just one form of noise.

Worked Example 29.1: Thermal Population Calculation

For a transmon qubit with $\omega_q/2\pi = 5.2\ \text{GHz}$ at various temperatures:

At 15 mK, the thermal population is negligible; at 4 K, nearly half the qubits would be in $|1\rangle$ by thermal excitation. This is why dilution refrigerators are essential.

29.1.1 The Dilution Refrigerator

A dilution refrigerator (DR) achieves temperatures of 5–20 mK by exploiting the phase separation of $^3$He–$^4$He mixtures. The operating principle:

1. A $^3$He–$^4$He mixture phase-separates below 0.87 K into a $^3$He-rich phase (concentrated) and a $^3$He-poor phase (dilute).
2. $^3$He atoms are pumped from the dilute phase into the concentrated phase, absorbing heat — analogous to evaporative cooling but using the enthalpy of mixing rather than latent heat.
3. The $^3$He is circulated back through room-temperature pumps, purified, and recondensed.

Detailed thermodynamics of dilution refrigeration:

The cooling power comes from the enthalpy of mixing. When $^3$He atoms cross the phase boundary from the concentrated phase to the dilute phase, they gain enthalpy because the dilute phase has lower $^3$He concentration. The enthalpy per mole of $^3$He in the dilute phase at temperature $T$ is:

$$H_d = \frac{3}{2}RT^2 / T_F$$

where $T_F$ is the Fermi temperature of the dilute phase. In the concentrated phase, the enthalpy is:

$$H_c = \frac{3}{2}RT$$

(since the concentrated phase behaves as an ideal Fermi gas at high concentration). The cooling power per mole of circulating $^3$He is:

$$\dot{Q} = \dot{n}_3 (H_d - H_c) \approx 84\ \dot{n}_3 T^2 \quad \text{[W]}$$

where $\dot{n}_3$ is the $^3$He circulation rate in mol/s. A typical DR with $\dot{n}_3 \sim 10^{-3}\ \text{mol/s}$ provides $\sim$400 $\mu\text{W}$ of cooling power at 100 mK, sufficient for a multi-qubit processor with its associated wiring and filtering.

Dilution Refrigerator Cross-Section

  Room Temperature (300 K)  ─────────────────────
      │  ↑                                        │
      │  │  Pump lines, gas handling              │
  ────●──●──────────────────────────────────────  │
      │  │                                        │
  Pulse Tube (50 K)  ────●─────────────────────   │
      │  │                │                        │
  Pulse Tube (4 K)   ────●─────────────────────   │
      │  │                │                        │
  Still (0.7 K)      ────●─────────────────────   │
      │  │                │                        │
  Cold Plate (100 mK) ──●─────────────────────    │
      │  │                │                        │
  Mixing Chamber      ──●─────────────────────    │
  (10-20 mK)              │                        │
                      [Qubit Chip]                  │
  ─────────────────────────────────────────────    │

  ● = Temperature stage with thermal anchoring
  │ = Coaxial wiring (attenuated, filtered, thermalized)

The mixing chamber: where quantum meets cryogenic

The mixing chamber is the coldest stage, where the phase boundary between the concentrated and dilute $^3$He phases exists. The qubit chip is mounted here, surrounded by multiple layers of magnetic shielding:

1. Mu-metal shield: Attenuates external magnetic fields by factor ~1000
2. Superconducting shield (aluminum or niobium): Expels residual fields via the Meissner effect
3. Cryoperm or Amumetal: Additional high-permeability shielding

The total magnetic field at the chip must be below $\sim 1\ \mu\text{T}$ to avoid vortices in the superconducting film that would create loss and decoherence.

29.1.2 Pulse Tube Precooling

Modern DRs use pulse tube cryocoolers for precooling to $\sim$4 K, eliminating the need for liquid helium. The pulse tube operates on a closed-cycle helium gas expansion, providing 1–2 W of cooling power at 4 K.

How a pulse tube works:

1. A helium compressor pressurizes the gas to ~20 bar
2. The gas flows through a regenerator (porous material that stores heat)
3. Expansion at the cold end produces cooling
4. The gas returns through the pulse tube (a hollow tube that provides the pressure oscillation)
5. A rotary valve alternates between high and low pressure

The pulse tube has no moving parts at the cold end, which reduces vibrations — critical for operating at millikelvin temperatures where even micrometer-scale vibrations can heat the qubit chip.

Try It Yourself: Cooling Power Budget

A dilution refrigerator has a cooling power of $Q = 84\dot{n}_3T^2$ at the mixing chamber. For $\dot{n}_3 = 10^{-3}\ \text{mol/s}$, what is the maximum heat load that can be tolerated at 15 mK while maintaining $T < 20\ \text{mK}$? If each coaxial line to the mixing chamber carries 0.5 $\mu\text{W}$ of heat, how many lines can be accommodated? (Answer: $Q(20\ \text{mK}) = 84 \times 10^{-3} \times (0.02)^2 = 33.6\ \mu\text{W}$. At 15 mK: $Q(15\ \text{mK}) = 18.9\ \mu\text{W}$. With 0.5 $\mu\text{W}$ per line, you can accommodate approximately 37 lines at 20 mK, or 37 lines at 15 mK with a margin of $\sim$15 $\mu\text{W}$.)

29.2 Wiring and Filtering

29.2.1 The Signal Chain

Each qubit requires multiple coaxial lines running from room temperature to the mixing chamber. A typical configuration for a single transmon qubit:

Why so many lines per qubit?

A modern transmon qubit requires at least 4 coaxial lines: one for the XY drive (microwave pulses for single-qubit gates), one for the Z flux line (DC and AC flux for frequency tuning), one for the readout input (microwave probe tone), and one for the readout output (amplified signal returning to room temperature). For tunable-coupler architectures, additional lines may be needed for each coupler. A 100-qubit processor with individual addressing requires 400+ coaxial lines, each running from 300 K to 15 mK.

29.2.2 Attenuation and Thermalization

Room-temperature microwave sources produce thermal noise corresponding to $T \sim 300\ \text{K}$. This noise must be attenuated to the level of millikelvin thermal photons. The attenuation at each temperature stage serves dual purposes:

1. Thermalization: Attenuators at each stage thermalize the propagating photons to the stage temperature. The effective noise photon number at the mixing chamber is:

$$\bar{n}_{\text{MC}} = \sum_{i} \bar{n}(T_i) \cdot \prod_{j>i} A_j^{-1}$$

where $A_j$ is the attenuation (linear) of stage $j$ and $\bar{n}(T_i) = 1/(e^{\hbar\omega/k_B T_i} - 1)$.

2. Filtering: Infrared (IR) filters block high-frequency ($>20\ \text{GHz}$) thermal radiation that would create quasiparticles in the superconductor. Low-pass filters (typically at the mixing chamber) suppress noise above the qubit frequency band.

Attenuation Budget (per line, 300 K → 15 mK)

  Stage        Temp     Attenuation    Cumulative    Noise Photons
  ─────────────────────────────────────────────────────────────
  300 K        300 K     0 dB            0 dB         ~1000
  50 K          50 K    10 dB           10 dB         ~10
  4 K            4 K    10 dB           20 dB         ~0.1
  Still        0.7 K    10 dB           30 dB         ~0.01
  Cold Plate  100 mK    20 dB           50 dB         ~10⁻⁴
  Mixing Ch.   15 mK    20 dB           70 dB         ~10⁻⁷

  Total: 70 dB attenuation → < 10⁻⁶ noise photons at qubit

Detailed noise calculation:

At 5 GHz, the thermal photon number at temperature $T$ is:

$$\bar{n}(T) = \frac{1}{e^{\hbar\omega/k_BT} - 1}$$

The attenuation chain reduces the 300 K thermal noise by a factor of $10^7$ (70 dB), bringing the effective noise photon number at the qubit to below $10^{-6}$. This is critical because even one excess thermal photon can excite the qubit from $|0\rangle$ to $|1\rangle$ with probability $P_{|1\rangle} \approx \bar{n}/(1+\bar{n})$.

Common Misconception: "Attenuators add noise."

This is true at room temperature — a room-temperature attenuator adds thermal noise at 300 K. But a cryogenic attenuator at 4 K adds noise at 4 K, which is negligible compared to the attenuated room-temperature signal. The key insight is that attenuators thermalize the signal to their own temperature. A 20 dB attenuator at 4 K reduces a 300 K signal by a factor of 100, and replaces it with 4 K noise — a net noise reduction of $\sim$75×. This is why we place attenuators at each cryogenic stage.

29.2.3 Materials and Thermal Conductivity

Coaxial cables must balance microwave performance with thermal conductivity. Common choices: - Stainless steel (low thermal conductivity): Used for the upper stages to minimize heat load. - Cupronickel (CuNi): Intermediate thermal conductivity. - Copper (high thermal conductivity): Used near the base temperature for good thermalization. - Superconducting NbTi: Zero DC resistance, used from 4 K down to the mixing chamber for low-loss signal transmission.

The heat load from wiring is a critical constraint. Each coaxial line from 300 K to 15 mK carries approximately 0.5–1 $\mu\text{W}$ of heat, even with careful thermal anchoring. For a 100-qubit processor with 400+ lines, the total heat load is 200–400 $\mu\text{W}$ — a significant fraction of the mixing chamber's cooling budget ($\sim$400 $\mu\text{W}$ at 100 mK, but only $\sim$10 $\mu\text{W}$ at 15 mK).

Worked Example 29.2: Heat Load Calculation

A stainless-steel coaxial cable (outer diameter 0.085", thermal conductivity integral $\int_{4\text{K}}^{300\text{K}} \kappa(T) dT \approx 10\ \text{W/m}$) of length 1 m between 4 K and 300 K conducts:

$$\dot{Q} = A \int_{T_1}^{T_2} \kappa(T) \frac{dT}{L} \approx \frac{A}{L} \times 10\ \text{W/m}$$

For a cable with cross-sectional area $A \approx 10^{-6}\ \text{m}^2$ and $L = 1\ \text{m}$:

$$\dot{Q} \approx 10^{-5}\ \text{W} = 10\ \mu\text{W}$$

With proper thermal anchoring at each temperature stage, the heat conducted to the mixing chamber can be reduced to $\sim$0.1 $\mu\text{W}$ per line. For 400 lines, this is 40 $\mu\text{W}$ — comparable to the cooling power at 15 mK.

29.2.4 Cryogenic Amplifiers: JPAs and TWPA

The readout signal leaving the qubit is extremely weak (typically $-130\ \text{dBm}$ to $-110\ \text{dBm}$). It must be amplified by $\sim$80 dB before reaching room-temperature electronics, but the first amplification stage must add minimal noise. Two technologies dominate:

Josephson Parametric Amplifiers (JPA):

A JPA uses a nonlinear inductor (a SQUID or Josephson junction array) pumped at twice the signal frequency to provide phase-sensitive amplification. Key properties: - Noise temperature: $< 100\ \text{mK}$ (near the quantum limit $T_N = \hbar\omega/2k_B \approx 120\ \text{mK}$ at 5 GHz) - Gain: 15–25 dB - Bandwidth: 1–10 MHz (narrow!) - Dynamic range: $-130\ \text{dBm}$ to $-120\ \text{dBm}$ (easily saturated)

Traveling Wave Parametric Amplifiers (TWPA):

A TWPA uses a long transmission line with periodic Josephson junctions, pumped to provide broadband parametric amplification. Key properties: - Noise temperature: $< 500\ \text{mK}$ - Gain: 15–20 dB - Bandwidth: 3–8 GHz (covers the entire qubit frequency range!) - Dynamic range: $-110\ \text{dBm}$ (much higher than JPA)

TWPAs are increasingly preferred for multi-qubit systems because their wide bandwidth allows frequency-multiplexed readout of many qubits through a single amplifier.

Readout Signal Chain (from qubit to room temperature)

  Qubit (15 mK)     ──── [Resonator] ──── ~-130 dBm
                                          │
  Isolators (15 mK) ──── [2-3 isolators] ── Prevent reflections
                                          │
  TWPA (15 mK)      ──── [+18 dB] ─────── ~-112 dBm
                                          │
  Coax (15→4 K)     ──── [-1 dB] ──────── ~-113 dBm
                                          │
  HEMT (4 K)        ──── [+35 dB] ─────── ~-78 dBm
                                          │
  Coax (4→300 K)    ──── [-3 dB] ──────── ~-81 dBm
                                          │
  RT Amplifier (300 K) ── [+40 dB] ────── ~-41 dBm
                                          │
  Digitizer         ──── [ADC] ────────── Digital signal

29.3 Room-Temperature Control Electronics

29.3.1 Arbitrary Waveform Generators (AWGs)

Arbitrary Waveform Generators produce the shaped microwave pulses that implement quantum gates. Key specifications:

• Sample rate: 1–10 GSa/s (gigasamples per second) to synthesize pulses at 4–8 GHz with sufficient oversampling.
• Vertical resolution: 14–16 bits for high-fidelity pulse shaping.
• Bandwidth: 1–4 GHz analog bandwidth.
• Channels: 4–8 channels per AWG module; a 100-qubit processor requires 200+ AWG channels.

The AWG stores pulse waveforms in memory and plays them back with precise timing. A typical Gaussian pulse for a $\pi/2$ rotation:

$$V(t) = V_0 \exp\left(-\frac{(t - t_0)^2}{2\sigma^2}\right) \cos(\omega_d t + \phi)$$

Why pulse shaping matters:

The Fourier transform of a rectangular pulse has sinc-function sidelobes that can excite neighboring qubits (spectral leakage). Gaussian pulses and DRAG (Derivative Removal by Adiabatic Gate) pulses suppress these sidelobes:

• Gaussian envelope: Reduces spectral width compared to rectangular, but still has residual excitation of higher transmon levels.
• DRAG correction: Adds a quadrature derivative component to cancel the $|1\rangle \rightarrow |2\rangle$ transition, improving gate fidelity by 10–100× for transmon qubits.
• Optimal control: Numerically optimized pulse shapes (GRAPE, CRAB algorithms) that maximize fidelity within bandwidth constraints.

29.3.2 IQ Mixers and Upconversion

Baseband AWG signals (DC–500 MHz) are upconverted to qubit frequencies (4–8 GHz) using IQ mixers. The AWG produces in-phase $I(t)$ and quadrature $Q(t)$ signals, which are mixed with a local oscillator (LO) at frequency $\omega_{\text{LO}}$:

$$V_{\text{RF}}(t) = I(t)\cos(\omega_{\text{LO}} t) - Q(t)\sin(\omega_{\text{LO}} t)$$

This enables independent control of the pulse amplitude and phase. Imperfections in the IQ mixer (amplitude imbalance $\Delta A$ and phase skew $\Delta\phi$) produce unwanted sidebands (image frequency) at a level:

$$\text{Image rejection} = 10\log_{10}\left(\frac{1 + 2\sqrt{1+\Delta A^2}\cos(\Delta\phi) + 1 + \Delta A^2}{1 - 2\sqrt{1+\Delta A^2}\cos(\Delta\phi) + 1 + \Delta A^2}\right) \approx -20\log_{10}\left(\frac{\sqrt{\Delta A^2 + \Delta\phi^2}}{2}\right)$$

For typical mixers, $\Delta A \sim 0.5\%$ and $\Delta\phi \sim 1°$, giving $\sim$40 dB image rejection. This is sufficient for most qubit operations, but for high-fidelity gates (< $10^{-4}$ error), the mixer must be calibrated to better than 0.1% amplitude balance and 0.1° phase balance.

Mixer calibration procedure:

1. Apply a DC offset to $I$ and $Q$ to null the LO leakage (carrier suppression)
2. Apply a test tone on $I$ only and measure the residual on $Q$ (image frequency)
3. Adjust $I$ and $Q$ amplitudes and phases to minimize the image
4. Repeat at different frequencies and amplitudes to build a calibration table

Modern control systems perform this calibration automatically every 1–4 hours.

29.3.3 Digitizers and Signal Processing

The returning readout signal is amplified, downconverted, and digitized. Analog-to-digital converters (ADCs) sample at 1–4 GSa/s with 12–14 bit resolution. The digitized signal is processed in real time:

1. Digital downconversion (DDC): Mix with a digital LO to baseband.
2. Matched filtering: Correlate with the expected pulse shape to maximize SNR.
3. State discrimination: Classify each shot as $|0\rangle$ or $|1\rangle$ based on the integrated quadrature amplitudes.

The integration result for a single shot is a point in the IQ plane:

$$I = \int_0^{\tau} V(t)\cos(\omega_{\text{IF}} t)\,dt, \quad Q = \int_0^{\tau} V(t)\sin(\omega_{\text{IF}} t)\,dt$$

The distributions of $(I, Q)$ for $|0\rangle$ and $|1\rangle$ form two Gaussian clouds; the optimal decision boundary is the line perpendicular to their separation vector.

Detailed readout analysis:

The readout fidelity depends on the overlap of the $|0\rangle$ and $|1\rangle$ distributions in the IQ plane. For Gaussian distributions with means $\mu_0, \mu_1$ and identical covariance $\sigma^2 I$:

$$F_{\text{readout}} = \frac{1}{2}\left(1 + \text{erf}\left(\frac{|\mu_1 - \mu_0|}{2\sqrt{2}\sigma}\right)\right) = \frac{1}{2}\left(1 + \text{erf}\left(\frac{\text{SNR}}{2\sqrt{2}}\right)\right)$$

where $\text{SNR} = |\mu_1 - \mu_0|/\sigma$ is the signal-to-noise ratio. For 99% readout fidelity, we need $\text{SNR} \geq 5.15$; for 99.9%, $\text{SNR} \geq 7.4$.

Try It Yourself: Readout SNR

A transmon qubit is read out with a dispersive shift of $\chi/2\pi = 2\ \text{MHz}$, a resonator linewidth of $\kappa/2\pi = 1\ \text{MHz}$, and a readout integration time of $\tau = 1\ \mu\text{s}$. The TWPA adds 0.5 photons of noise. Estimate the SNR and readout fidelity. (Answer: The dispersive shift produces a phase shift of $\arctan(2\chi/\kappa) \approx \pi/2$ between $|0\rangle$ and $|1\rangle$ responses. With 0.5 noise photons, $\text{SNR} \approx \sqrt{n_{\text{photons}}} \cdot \chi\tau \approx 6$, giving $F_{\text{readout}} \approx 99\%$.)

29.4 The Quantum–Classical Interface

29.4.1 From Qiskit to Pulses

The full stack translates a user's quantum circuit into physical pulses:

User Layer:     qc = QuantumCircuit(2); qc.h(0); qc.cx(0,1)
                      │
Transpilation:  Map to hardware topology, optimize gates
                      │
Scheduling:     Insert delays, align pulses in time
                      │
Pulse Level:    Convert gates to microwave pulse sequences
                      │
Waveform Gen:   Compute I/Q samples for AWG playback
                      │
Analog Output:  AWG → IQ Mixer → Attenuators → Qubit
                      │
Measurement:    Readout pulse → JPA → HEMT → ADC → Discriminator
                      │
Result:         Counts: {'00': 512, '11': 488}

Detailed transpilation example:

A simple circuit qc.h(0); qc.cx(0,1) on a transmon processor with specific hardware constraints must be decomposed as follows:

1. H gate decomposition: $H = R_z(\pi/2) \cdot R_x(\pi/2) \cdot R_z(\pi/2)$ (since transmons natively implement $R_x$ and $R_z$ rotations)
2. CNOT decomposition: $\text{CNOT} = R_z^{(1)}(\pi/2) \cdot \text{CR}(\pi/2) \cdot R_z^{(0)}(-\pi/2) \cdot R_z^{(1)}(-\pi/2) \cdot R_x^{(1)}(-\pi/2)$ (where CR is the cross-resonance gate)
3. Pulse-level decomposition: Each $R_x(\theta)$ becomes a Gaussian-envelope microwave pulse with duration $t = \theta/\Omega_{\text{Rabi}}$ and amplitude $V_0$
4. Scheduling: Insert idle times between pulses to account for qubit decoherence and cross-talk

29.4.2 Latency Budget

The round-trip latency from instruction to measurement result is critical for error correction, where measurement outcomes must feed back into subsequent operations. Typical latencies:

For surface code error correction with a $\sim$1 $\mu$s cycle time, this latency must be reduced. Cryogenic CMOS controllers operating at 4 K can reduce cable propagation delays and enable faster feedback.

Why latency matters for error correction:

The surface code requires measuring stabilizer operators and applying conditional corrections within one error correction cycle. If the cycle time is $t_{\text{cycle}} \sim 1\ \mu\text{s}$ and the round-trip latency is $t_{\text{RT}} \sim 3\ \mu\text{s}$, then the classical processing takes 3× longer than the quantum operations. This means the qubits must idle for 2 $\mu\text{s}$ while waiting for the feedforward, accumulating errors at rate $1/T_1 + 1/T_2$. For $T_1 = 100\ \mu\text{s}$, this idle time adds $\sim$2% error per cycle — comparable to the gate error itself.

Solutions being developed: - Cryogenic CMOS controllers at 4 K (Intel Horse Ridge, Google cryo-CMOS) - FPGA-based real-time processing with sub-$\mu\text{s}$ decision loops - Autonomous error correction using engineered dissipation (no classical feedback needed)

29.4.3 Real-Time Control Systems

Modern quantum control systems (e.g., Quantum Machines OPX+, Zurich Instruments SHFQC, Keysight Quantum Control System) integrate AWG, digitizer, and FPGA-based real-time processing in a single chassis. The FPGA implements:

• Real-time state estimation: Kalman filters or hidden Markov models for optimal qubit state tracking.
• Adaptive pulse generation: Conditional pulse sequences based on mid-circuit measurements.
• Error syndrome decoding: Real-time decoding of surface code syndromes for active error correction.

The FPGA processes the digitized readout signal in real time, computing the IQ amplitudes and comparing against calibrated thresholds within 100 ns of the readout pulse ending. This enables conditional operations (feedforward) that are essential for error correction and teleportation protocols.

29.5 Qubit Calibration

29.5.1 Qubit Spectroscopy

The first calibration step is finding the qubit frequency. A continuous-wave (CW) tone is swept across the expected frequency range while monitoring the readout resonator response. When the drive is resonant with $\omega_{01}$, the qubit is excited, producing a dispersive shift in the resonator frequency:

Qubit Spectroscopy

  Sweep drive frequency ω_d across 4-6 GHz
  Monitor readout resonator phase shift

  Phase Shift
      ^
      |         ┌─┐
      |         │ │  ← Resonance at ω_q
      |─────────┘ └─────────
      +------------------------> ω_d

Detailed spectroscopy procedure:

1. Coarse resonator spectroscopy: Sweep a probe tone across 6–8 GHz with 1 MHz resolution to find the readout resonator frequency $\omega_r$.
2. Fine resonator spectroscopy: Zoom into $\omega_r$ with 10 kHz resolution to measure the resonator linewidth $\kappa$ and extract the coupling rate $g$ from the vacuum Rabi splitting.
3. Qubit spectroscopy: With the resonator found, apply a drive tone and monitor the dispersive shift. The qubit frequency appears as a dip or peak in the resonator response, depending on the readout scheme.

29.5.2 Rabi Experiment

A Rabi experiment calibrates the relationship between pulse amplitude and rotation angle. A Gaussian pulse of variable amplitude is applied, followed by measurement. The resulting population oscillates as:

$$P_{|1\rangle}(A) = A_0 \sin^2(\pi A / A_\pi) + B$$

where $A_\pi$ is the amplitude for a $\pi$-pulse. Fitting this curve yields the calibration factor.

Detailed Rabi oscillation physics:

For a qubit driven by a resonant microwave field with Rabi frequency $\Omega_R$:

$$|\psi(t)\rangle = \cos\left(\frac{\Omega_R t}{2}\right)|0\rangle - i\sin\left(\frac{\Omega_R t}{2}\right)|1\rangle$$

The Rabi frequency is proportional to the drive amplitude: $\Omega_R = d \cdot E / \hbar$, where $d$ is the transition dipole moment and $E$ is the electric field amplitude. Since the AWG output voltage is proportional to $E$, we have $\Omega_R \propto V_{\text{AWG}}$, and the $\pi$-pulse amplitude is $V_\pi = \pi/(t_{\text{pulse}} \cdot d/\hbar)$.

In practice, the Rabi oscillation is not a perfect sinusoid. Decoherence causes the oscillation amplitude to decay, and transmon qubits have higher levels ($|2\rangle$, $|3\rangle$, ...) that can be populated if the drive is too strong. DRAG pulses correct for these effects.

# Qiskit: Rabi experiment for pi-pulse calibration
import numpy as np
from qiskit_experiments.library import Rabi
from qiskit_experiments.framework import ExperimentData

# Sweep pulse amplitudes
rabi_exp = Rabi(
    qubit=0,
    amplitudes=np.linspace(0.0, 1.0, 51)
)

# After running on hardware:
# rabi_data = rabi_exp.run(backend)
# pi_amplitude = rabi_data.analysis_results('rabi_rate').value
# print(f"Pi-pulse amplitude: {pi_amplitude:.4f}")

29.5.3 Ramsey Experiment and $T_2^*$

The Ramsey experiment measures the qubit's dephasing time $T_2^*$ and calibrates the qubit frequency precisely. The sequence:

1. $R_x(\pi/2)$ — prepare superposition $|+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}$
2. Wait time $\tau$
3. $R_x(\pi/2)$ — rotate back for measurement
4. Measure $P_{|1\rangle}$

With a deliberate detuning $\Delta$, the Ramsey fringes are:

$$P_{|1\rangle}(\tau) = \frac{1}{2} + \frac{1}{2} \cos(2\pi\Delta\tau) e^{-\tau/T_2^*}$$

The exponential decay envelope gives $T_2^*$, and the oscillation frequency gives the precise detuning $\Delta$, enabling fine frequency calibration.

Ramsey Fringes

  P(|1⟩)
    1.0 ┤  ╭─╮     ╭─╮     ╭─╮
        │ ╱ ╲   ╱ ╲   ╱ ╲
    0.5 ┤╱   ╲ ╱   ╲ ╱   ╲
        │      ╳      ╳
    0.0 ┤
        +──────────────────────────> τ
        |←── T₂* decay envelope ──→|

Detailed analysis of Ramsey fringes:

The Ramsey signal is the interference between the qubit's accumulated phase and the reference oscillator's phase. The accumulated phase during free evolution is:

$$\phi(\tau) = \int_0^{\tau} \delta\omega(t) dt$$

where $\delta\omega(t)$ is the instantaneous frequency deviation. For quasi-static noise ($\delta\omega(t) = \text{const}$ during each shot, but varies between shots), the Ramsey signal is:

$$P_{|1\rangle}(\tau) = \frac{1}{2}\left(1 + e^{-\tau/T_2^*}\cos(2\pi\Delta\tau)\right)$$

where $T_2^*$ is related to the frequency noise spectral density at low frequencies by $T_2^* = \sqrt{2}/(\gamma \sqrt{S_{\delta\omega}(0)})$, with $\gamma$ the gyromagnetic ratio. Typical values: $T_2^* \sim 20\text{–}100\ \mu\text{s}$ for transmon qubits.

29.5.4 $T_1$ Measurement

The energy relaxation time $T_1$ is measured by: 1. Apply an $X_\pi$ pulse to excite to $|1\rangle$. 2. Wait a variable time $\tau$. 3. Measure $P_{|1\rangle}$.

The decay follows:

$$P_{|1\rangle}(\tau) = A e^{-\tau/T_1} + B$$

where $A \approx 1$ and $B \approx 0$ (ideally). The $T_1$ time is the primary coherence metric for a qubit.

Physical origins of $T_1$:

The energy relaxation rate $1/T_1$ is the sum of contributions from various noise sources:

$$\frac{1}{T_1} = \frac{1}{T_1^{\text{dielectric}}} + \frac{1}{T_1^{\text{quasiparticle}}} + \frac{1}{T_1^{\text{radiation}}} + \frac{1}{T_1^{\text{Purcell}}}$$

• Dielectric loss: Electric field noise from two-level systems (TLS) in amorphous oxides (AlO$_x$, SiO$_x$) at surfaces and interfaces. This is often the dominant source.
• Quasiparticle tunneling: Broken Cooper pairs in the Josephson junction tunnel across and dissipate energy. Mitigated by quasiparticle traps and improved materials.
• Radiative decay: The qubit radiates energy into the readout resonator (Purcell effect). Mitigated by Purcell filters.
• Other sources: Vortex loss, paramagnetic impurities, cosmic rays.

Typical $T_1$ values for transmon qubits: 50–500 $\mu\text{s}$ (2024 state of the art).

29.5.5 Hahn Echo and $T_2^{\text{echo}}$

The Hahn echo sequence refocuses low-frequency (quasi-static) dephasing: 1. $R_x(\pi/2)$ 2. Wait $\tau/2$ 3. $R_x(\pi)$ — refocusing pulse 4. Wait $\tau/2$ 5. $R_x(\pi/2)$ 6. Measure

The echo decay gives $T_2^{\text{echo}}$, which is typically $T_2^{\text{echo}} \approx 2T_1$ for a $T_1$-limited qubit. The ratio $T_2^{\text{echo}} / (2T_1)$ indicates the fraction of dephasing that is refocusable.

Why the Hahn echo works:

Consider a qubit that accumulates phase $\phi_1$ during the first $\tau/2$ and $\phi_2$ during the second $\tau/2$. Without the echo pulse, the total phase is $\phi_1 + \phi_2$. With the $\pi$ pulse at $\tau/2$, the phase evolution is reversed: the accumulated phase becomes $\phi_1 - \phi_2$. For quasi-static noise ($\phi_1 = \phi_2$), the total phase is zero — the dephasing is refocused. Only noise that fluctuates on timescales shorter than $\tau$ survives, and these fast fluctuations contribute to $1/T_2^{\text{echo}} - 1/(2T_1)$.

Try It Yourself: Dephasing Time Hierarchy

For a transmon qubit with $T_1 = 100\ \mu\text{s}$ and $T_2^* = 20\ \mu\text{s}$: (a) What is $T_2^{\text{echo}}$ if the dephasing is equally split between quasi-static and fast noise? (b) What is the fraction of quasi-static noise? (c) How many CPMG pulses ($N$ echo pulses) are needed to extend $T_2$ to $50\ \mu\text{s}$?

Answers: (a) $1/T_2^{\text{echo}} = 1/(2T_1) + 1/T_{2,\text{fast}}^*$. If quasi-static noise accounts for half: $1/T_2^* = 1/(2T_1) + 1/T_{2,\text{fast}}^* + 1/T_{2,\text{slow}}^*$. With $T_2^* = 20\ \mu\text{s}$ and $T_1 = 100\ \mu\text{s}$: $1/20 = 1/200 + 1/T_{2,\text{fast}}^* + 1/T_{2,\text{slow}}^*$. If slow and fast are equal: $1/T_2^{\text{echo}} = 1/200 + 2/T_{2,\text{fast}}^* = 1/200 + 2 \times 0.02 = 0.04$, giving $T_2^{\text{echo}} = 24\ \mu\text{s}$.

29.5.6 Randomized Benchmarking

Randomized benchmarking (RB) measures the average gate fidelity by applying random sequences of Clifford gates of increasing length. The sequence fidelity decays as:

$$F(m) = A p^m + B$$

where $m$ is the number of Cliffords and $p$ is the depolarizing parameter. The average gate error per Clifford is:

$$r = (1 - p)\left(1 - \frac{1}{d}\right)$$

where $d = 2^n$ for $n$ qubits. Interleaved RB measures the fidelity of a specific gate by interleaving it between random Cliffords.

Why randomized benchmarking instead of process tomography?

Process tomography requires $d^4$ measurements (where $d = 2^n$) and is extremely sensitive to state preparation and measurement (SPAM) errors. RB, on the other hand: - Is SPAM-robust (the SPAM errors contribute only to $A$ and $B$, not to $p$) - Scales efficiently (only $O(1)$ measurements per sequence length for a given target precision) - Measures the average error, which is the relevant quantity for error correction - Is applicable to individual gates (interleaved RB) and two-qubit gates

The key insight is that random Clifford gates form a 2-design — they uniformly sample the space of all possible errors, so the average over random sequences converges to a simple depolarizing channel.

29.6 Automated Calibration Pipelines

29.6.1 The Calibration Workflow

A full qubit calibration involves dozens of experiments, typically run in sequence:

Calibration Pipeline

  1. Resonator Spectroscopy     → Find readout resonator frequencies
  2. Qubit Spectroscopy         → Find qubit frequencies (coarse)
  3. Rabi Experiment            → Calibrate pi-pulse amplitude
  4. Ramsey Experiment          → Fine-tune qubit frequency, measure T₂*
  5. T₁ Experiment              → Measure energy relaxation time
  6. Hahn Echo                  → Measure T₂^echo
  7. Readout Optimization       → Optimize readout frequency, power, duration
  8. Readout Discrimination     → Train state classifier
  9. Single-Qubit RB            → Measure 1Q gate fidelity
  10. Two-Qubit Gate Calibration → Optimize CR/tunable coupler parameters
  11. Two-Qubit RB              → Measure 2Q gate fidelity
  12. Crosstalk Characterization → Measure and mitigate crosstalk

Why automated calibration is essential:

A 100-qubit processor requires calibrating ~200 parameters (frequencies, amplitudes, phases, readout thresholds for each qubit, plus coupling strengths and gate parameters for each pair). Manual calibration of each parameter would require days of experimental time — and by the time calibration is complete, the parameters may have drifted. Automated pipelines reduce this to hours, and machine learning techniques can further optimize the process by learning correlations between parameters and predicting optimal values.

29.6.2 Drift and Recalibration

Qubit parameters drift over timescales of minutes to hours due to: - Temperature fluctuations in the mixing chamber (0.1–1 mK variations) - Flux drift from trapped flux in the SQUID loop - Quasiparticle density variations (cosmic ray hits, thermal fluctuations) - Two-level system (TLS) fluctuations in dielectrics

Automated recalibration runs periodically (every 1–4 hours) to maintain gate fidelity. Machine learning techniques are increasingly used for rapid recalibration, reducing the overhead from hours to minutes.

TLS (two-level system) fluctuations:

TLS are defects in amorphous oxide layers (AlO$_x$, SiO$_x$) at the surface of the qubit capacitor. Each TLS is a two-level system with a random resonance frequency and dipole moment that couples to the qubit's electric field. When a TLS resonance frequency drifts through the qubit frequency, it creates a frequency shift:

$$\delta\omega_q \approx \frac{g_{\text{TLS}}^2}{\omega_q - \omega_{\text{TLS}}}$$

where $g_{\text{TLS}}$ is the qubit-TLS coupling strength. This can shift the qubit frequency by 0.1–1 MHz on timescales of minutes to hours, requiring frequent recalibration.

29.6.3 Qiskit Calibration Experiments

from qiskit_experiments.library import (
    QubitSpectroscopy,
    Rabi,
    RamseyXY,
    T1,
    T2Hahn,
    StandardRB,
    CrossResonanceHamiltonian,
)
from qiskit_experiments.framework import ParallelExperiment
import numpy as np

# Define calibration experiments for a single qubit
qubit = 0

experiments = [
    QubitSpectroscopy(qubit, frequencies=np.linspace(4.5e9, 5.5e9, 101)),
    Rabi(qubit, amplitudes=np.linspace(0, 1.0, 51)),
    RamseyXY(qubit, delays=np.linspace(0, 50e-6, 101)),
    T1(qubit, delays=np.linspace(0, 200e-6, 51)),
    T2Hahn(qubit, delays=np.linspace(0, 200e-6, 51)),
    StandardRB(qubit, lengths=[1, 2, 4, 8, 16, 32, 64, 128]),
]

print("Calibration pipeline defined:")
for exp in experiments:
    print(f"  - {exp.__class__.__name__}")

# In production, these run on hardware:
# for exp in experiments:
#     data = exp.run(backend)
#     data.block_for_results()
#     print(f"{exp.__class__.__name__}: {data.analysis_results()}")

Additional Qiskit Example: Full System Simulation with Crosstalk

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error, \
    cross_talk_error, readout_error

def create_system_noise_model(n_qubits, t1=100e-6, t2=50e-6, 
                               gate_time_1q=20e-9, gate_time_2q=200e-9,
                               crosstalk_strength=0.01):
    """Create a realistic noise model for a multi-qubit system."""
    noise_model = NoiseModel()

    # Single-qubit thermal relaxation
    error_1q = thermal_relaxation_error(t1, t2, gate_time_1q)
    noise_model.add_all_qubit_quantum_error(error_1q, ['rx', 'ry', 'rz', 'h'])

    # Two-qubit thermal relaxation
    error_2q = thermal_relaxation_error(t1, t2, gate_time_2q).expand(
                thermal_relaxation_error(t1, t2, gate_time_2q))
    noise_model.add_all_qubit_quantum_error(error_2q, ['cx', 'cz'])

    # Readout error (1-2% per qubit)
    for i in range(n_qubits):
        readout_err = readout_error.ReadoutError([[0.98, 0.02], [0.02, 0.98]])
        noise_model.add_readout_error(readout_err, [i])

    return noise_model

# Create and test the noise model
n_qubits = 5
noise_model = create_system_noise_model(n_qubits)

# Simulate a simple circuit
sim = AerSimulator(noise_model=noise_model)
qc = QuantumCircuit(n_qubits)
qc.h(0)
for i in range(n_qubits - 1):
    qc.cx(i, i + 1)
qc.measure_all()

result = sim.run(transpile(qc, sim), shots=10000).result()
counts = result.get_counts()
print("GHZ state with realistic noise:")
for state, count in sorted(counts.items(), key=lambda x: -x[1])[:5]:
    print(f"  |{state}⟩: {count/100:.1f}%")

# Compare with ideal
ideal_result = AerSimulator().run(transpile(qc, AerSimulator()), shots=10000).result()
ideal_counts = ideal_result.get_counts()
print("\nIdeal GHZ state:")
for state, count in sorted(ideal_counts.items(), key=lambda x: -x[1])[:5]:
    print(f"  |{state}⟩: {count/100:.1f}%")

# Calculate fidelity
from qiskit.quantum_info import Statevector
ideal_state = Statevector.from_instruction(qc.remove_final_measurements(inplace=False))
noisy_probs = np.zeros(2**n_qubits)
for state, count in counts.items():
    noisy_probs[int(state, 2)] = count / 10000
fidelity = ideal_state.probabilities() @ np.sqrt(noisy_probs / (ideal_state.probabilities() + 1e-10))
print(f"\nState fidelity with noise: {fidelity:.4f}")

29.7 Data Centers for Quantum Computers

29.7.1 Physical Infrastructure

A quantum data center houses multiple quantum computers along with their support systems:

• Dilution refrigerators: Each DR occupies $\sim$2 m$^2$ of floor space and stands $\sim$3 m tall. A data center may house 10–100 DRs.
• Control electronics racks: Each qubit requires $\sim$1U of rack space for AWG and digitizer channels. A 1000-qubit processor needs $\sim$10–20 equipment racks.
• Cryogenic infrastructure: Pulse tube compressors require water cooling ($\sim$10 kW per DR) and helium gas handling systems.
• Vibration isolation: The DR must be mechanically isolated from building vibrations (floor oscillations, HVAC) to sub-micron amplitudes.
• Electromagnetic shielding: The qubit chip is shielded from ambient magnetic fields (including Earth's $\sim$50 $\mu\text{T}$ field) by multiple layers of mu-metal and superconducting shields.

Common Misconception: "Quantum computers will replace classical computers in data centers."

Quantum computers are not replacements for classical computers — they are specialized accelerators for specific problem classes (optimization, simulation, factoring). A quantum data center will have classical servers for job scheduling, error correction decoding, and pre/post-processing, alongside quantum processors. The quantum–classical hybrid model is the realistic near-term architecture.

29.7.2 Cost Model

The capital cost of a superconducting quantum computer scales roughly as:

Detailed cost breakdown for a 1000-qubit system:

Operating costs include electricity ($\sim$50K/year per DR), liquid helium (if not cryogen-free), and specialized maintenance personnel.

29.7.3 Cloud Access Model

Most users access quantum computers via cloud platforms (IBM Quantum, Amazon Braket, Microsoft Azure Quantum, Google Quantum AI). The cloud model abstracts away the physical infrastructure, providing:

• Job queuing and scheduling: Fair-share scheduling across multiple users.
• Error mitigation: Built-in error suppression and mitigation techniques.
• Reservation systems: Dedicated time slots for sensitive experiments.
• Hybrid quantum–classical: Tight integration with classical compute (CPUs, GPUs) for variational algorithms.

Pricing models:

29.8 The Full Stack: User to Qubit

The Quantum Computing Stack

  ┌─────────────────────────────────────────────┐
  │  Application Layer                          │
  │  (Chemistry, Optimization, ML, Cryptography)│
  ├─────────────────────────────────────────────┤
  │  Algorithm Layer                            │
  │  (VQE, QAOA, Shor, Grover, QPE)             │
  ├─────────────────────────────────────────────┤
  │  Circuit Layer                              │
  │  (Qiskit, Cirq, Q#, Pennylane)              │
  ├─────────────────────────────────────────────┤
  │  Compiler / Transpiler                      │
  │  (Optimization, Qubit Mapping, Scheduling)   │
  ├─────────────────────────────────────────────┤
  │  Pulse Layer                                │
  │  (Gate → Pulse conversion, Calibration)     │
  ├─────────────────────────────────────────────┤
  │  Control Electronics                        │
  │  (AWG, Digitizer, FPGA, Real-time control)   │
  ├─────────────────────────────────────────────┤
  │  Cryogenic Wiring & Filtering               │
  │  (Attenuators, Amplifiers, Filters)          │
  ├─────────────────────────────────────────────┤
  │  Quantum Processor                          │
  │  (Qubit chip, Readout resonators, Couplers) │
  └─────────────────────────────────────────────┘

Each layer presents an abstraction boundary. The circuit layer sees logical qubits and gates; the pulse layer sees physical qubits and microwave pulses; the control electronics see digital samples and analog voltages. Understanding these layers and their interactions is essential for both using and building quantum computers.

The transpilation pipeline in detail:

1. High-level circuit: User writes qc.h(0); qc.cx(0,1); qc.measure_all()
2. Basis gate decomposition: Decompose to hardware-native gate set (e.g., $\{R_x, R_z, \text{CR}\}$)
3. Qubit mapping: Assign logical qubits to physical qubits based on connectivity and calibration data
4. Routing: Insert SWAP gates to satisfy connectivity constraints
5. Scheduling: Assign start times to each gate, accounting for gate durations and latency
6. Pulse generation: Convert each gate to calibrated microwave pulse envelopes
7. AWG upload: Download waveforms to AWG memory

The entire pipeline must complete in seconds for interactive use, and each step introduces potential errors or suboptimalities that affect the final circuit fidelity.

29.9 Qiskit Code: Full Calibration and System Simulation

import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, pulse, schedule
from qiskit.providers.fake_provider import FakeValencia

# Load a mock backend with realistic parameters
backend = FakeValencia()
config = backend.configuration()
print(f"Backend: {config.backend_name}")
print(f"Qubits: {config.n_qubits}")
print(f"Qubit frequencies: {[f'{f/1e9:.3f} GHz' for f in config.qubit_frequencies]}")

# Simulate a Ramsey experiment
def simulate_ramsey(t2_star, detuning, delays):
    """Simulate Ramsey fringes with T2* decay."""
    signal = 0.5 + 0.5 * np.cos(2 * np.pi * detuning * delays) * np.exp(-delays / t2_star)
    # Add Gaussian noise
    noise = np.random.normal(0, 0.02, len(delays))
    return signal + noise

# Parameters
T2_star = 50e-6  # 50 μs
detuning = 0.1e6  # 100 kHz deliberate detuning
delays = np.linspace(0, 100e-6, 101)

ramsey_data = simulate_ramsey(T2_star, detuning, delays)

# Fit the Ramsey data
from scipy.optimize import curve_fit

def ramsey_model(t, A, B, f, T2):
    return A + B * np.cos(2 * np.pi * f * t) * np.exp(-t / T2)

popt, pcov = curve_fit(
    ramsey_model, delays, ramsey_data,
    p0=[0.5, 0.5, detuning, T2_star]
)

print(f"\nRamsey Fit Results:")
print(f"  T2* = {popt[3]*1e6:.1f} μs (true: {T2_star*1e6:.0f} μs)")
print(f"  Detuning = {popt[2]/1e3:.1f} kHz (true: {detuning/1e3:.0f} kHz)")

# Simulate T1 decay
def simulate_t1(t1, delays):
    """Simulate T1 energy relaxation."""
    signal = np.exp(-delays / t1)
    noise = np.random.normal(0, 0.02, len(delays))
    return signal + noise

T1 = 100e-6  # 100 μs
t1_delays = np.linspace(0, 200e-6, 51)
t1_data = simulate_t1(T1, t1_delays)

def t1_model(t, A, T1, B):
    return A * np.exp(-t / T1) + B

popt_t1, _ = curve_fit(t1_model, t1_delays, t1_data, p0=[1.0, T1, 0.0])
print(f"\nT1 Fit Results:")
print(f"  T1 = {popt_t1[1]*1e6:.1f} μs (true: {T1*1e6:.0f} μs)")

# Randomized Benchmarking simulation
def simulate_rb(depolarizing_prob, sequence_lengths, shots=1024):
    """Simulate randomized benchmarking decay."""
    d = 2  # single qubit
    fidelities = []
    for m in sequence_lengths:
        # Average fidelity after m Cliffords
        avg_fidelity = (1/d) + (1 - 1/d) * (1 - depolarizing_prob)**m
        # Binomial sampling noise
        counts = np.random.binomial(shots, avg_fidelity)
        fidelities.append(counts / shots)
    return np.array(fidelities)

rb_lengths = [1, 2, 4, 8, 16, 32, 64, 128, 256]
rb_data = simulate_rb(0.005, rb_lengths)

def rb_model(m, A, p, B):
    return A * p**m + B

popt_rb, _ = curve_fit(rb_model, rb_lengths, rb_data, p0=[0.5, 0.99, 0.5])
error_per_clifford = (1 - popt_rb[1]) * (1 - 1/2)
print(f"\nRandomized Benchmarking Results:")
print(f"  Depolarizing parameter p = {popt_rb[1]:.4f}")
print(f"  Error per Clifford = {error_per_clifford*100:.3f}%")
print(f"  Error per gate (approx) = {error_per_clifford/1.875*100:.3f}%")

# Plotting
fig, axes = plt.subplots(1, 3, figsize=(15, 4))

axes[0].plot(delays*1e6, ramsey_data, 'b.', markersize=2, label='Data')
axes[0].plot(delays*1e6, ramsey_model(delays, *popt), 'r-', label='Fit')
axes[0].set_xlabel('Delay (μs)')
axes[0].set_ylabel('P(|1⟩)')
axes[0].set_title('Ramsey Experiment')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

axes[1].plot(t1_delays*1e6, t1_data, 'b.', markersize=3, label='Data')
axes[1].plot(t1_delays*1e6, t1_model(t1_delays, *popt_t1), 'r-', label='Fit')
axes[1].set_xlabel('Delay (μs)')
axes[1].set_ylabel('P(|1⟩)')
axes[1].set_title('T₁ Experiment')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

axes[2].semilogx(rb_lengths, rb_data, 'b.', markersize=5, label='Data')
axes[2].semilogx(rb_lengths, rb_model(rb_lengths, *popt_rb), 'r-', label='Fit')
axes[2].set_xlabel('Sequence Length (Cliffords)')
axes[2].set_ylabel('Sequence Fidelity')
axes[2].set_title('Randomized Benchmarking')
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('calibration_experiments.png', dpi=150)
plt.show()

print("\nCalibration plots saved to calibration_experiments.png")

Additional Qiskit Example: System-Level Error Budget

import numpy as np

def total_circuit_fidelity(n_qubits, n_1q_gates, n_2q_gates, n_measurements,
                           f1q=0.999, f2q=0.998, f_readout=0.99,
                           f_spam=0.995, t_gate_1q=20e-9, t_gate_2q=200e-9,
                           t_readout=1e-6, t1=100e-6, t2_star=20e-6):
    """Calculate total circuit fidelity from all error sources."""

    # Gate errors
    error_1q = 1 - f1q**n_1q_gates
    error_2q = 1 - f2q**n_2q_gates
    error_readout = 1 - f_readout**n_measurements
    error_spam = 1 - f_spam**(2*n_qubits)  # prep + meas per qubit

    # Decoherence errors (idle time between gates)
    t_total = n_1q_gates * t_gate_1q + n_2q_gates * t_gate_2q + n_measurements * t_readout
    error_t1 = 1 - np.exp(-t_total / t1)
    error_t2 = 1 - np.exp(-t_total / t2_star)

    # Total fidelity (assuming independent errors)
    total_fidelity = (f1q**n_1q_gates * f2q**n_2q_gates * 
                      f_readout**n_measurements * f_spam**(2*n_qubits) *
                      np.exp(-t_total/t1) * np.exp(-t_total/t2_star))

    print(f"Circuit: {n_qubits} qubits, {n_1q_gates} 1Q gates, {n_2q_gates} 2Q gates")
    print(f"Total circuit time: {t_total*1e6:.1f} μs")
    print(f"\nError budget:")
    print(f"  1Q gate errors:         {error_1q*100:.2f}%")
    print(f"  2Q gate errors:         {error_2q*100:.2f}%")
    print(f"  Readout errors:         {error_readout*100:.2f}%")
    print(f"  SPAM errors:            {error_spam*100:.2f}%")
    print(f"  T1 decoherence:         {error_t1*100:.2f}%")
    print(f"  T2* dephasing:          {error_t2*100:.2f}%")
    print(f"  Total circuit fidelity: {total_fidelity*100:.2f}%")

    return total_fidelity

# Example: 5-qubit GHZ circuit
print("=== 5-qubit GHZ circuit ===")
total_circuit_fidelity(
    n_qubits=5, n_1q_gates=5, n_2q_gates=4, n_measurements=5,
    f1q=0.9995, f2q=0.999, f_readout=0.99, t1=150e-6, t2_star=50e-6
)

# Example: 20-qubit QFT circuit
print("\n=== 20-qubit QFT circuit ===")
n_2q_qft = 20 * 19 // 2  # all-to-all connectivity
total_circuit_fidelity(
    n_qubits=20, n_1q_gates=20+10, n_2q_gates=n_2q_qft, n_measurements=20,
    f1q=0.9995, f2q=0.999, f_readout=0.98, t1=100e-6, t2_star=30e-6
)

# Example: Surface code error correction cycle
print("\n=== Surface code (d=5) cycle ===")
total_circuit_fidelity(
    n_qubits=25, n_1q_gates=100, n_2q_gates=60, n_measurements=25,
    f1q=0.9999, f2q=0.999, f_readout=0.99, t1=200e-6, t2_star=100e-6
)

29.10 Readout Techniques in Detail

29.10.1 Dispersive Readout

The standard readout technique for superconducting qubits is dispersive readout, based on the Jaynes–Cummings interaction between a qubit and a resonator. In the dispersive regime ($|g| \gg \Delta$, where $\Delta = \omega_q - \omega_r$), the effective Hamiltonian is:

$$\hat{H}_{\text{disp}} = \frac{\hbar}{2}\omega_q\hat{\sigma}_z + \hbar\left(\omega_r + \chi\hat{\sigma}_z\right)\hat{a}^\dagger\hat{a}$$

where $\chi = g^2/\Delta$ is the dispersive shift. The resonator frequency shifts by $\pm\chi$ depending on the qubit state: $\omega_r + \chi$ when the qubit is in $|0\rangle$ and $\omega_r - \chi$ when in $|1\rangle$.

By probing the resonator at a frequency near $\omega_r$, the reflected or transmitted signal acquires a qubit-state-dependent phase shift:

$$\phi_0 = \arctan\left(\frac{2\chi/\kappa}{1 + (\Delta_r + \chi)/(\kappa/2)}\right), \quad \phi_1 = \arctan\left(\frac{-2\chi/\kappa}{1 + (\Delta_r - \chi)/(\kappa/2)}\right)$$

where $\kappa$ is the resonator linewidth and $\Delta_r$ is the probe detuning from $\omega_r$. The optimal probe frequency maximizes $|\phi_0 - \phi_1|$, giving the best state discrimination.

Worked Example 29.3: Readout Optimization

For a transmon qubit with $\omega_q/2\pi = 5.0$ GHz, $\omega_r/2\pi = 7.0$ GHz, $g/2\pi = 100$ MHz:

$$\chi = \frac{g^2}{\Delta} = \frac{(2\pi \times 100 \times 10^6)^2}{2\pi \times 2 \times 10^9} = 2\pi \times 5\ \text{MHz}$$

With resonator linewidth $\kappa/2\pi = 1$ MHz, the frequency shift between $|0\rangle$ and $|1\rangle$ is $2\chi/2\pi = 10$ MHz, which is $10\times$ the linewidth. This gives a high-contrast readout: the $|0\rangle$ and $|1\rangle$ states produce clearly distinguishable responses.

The Purcell effect limits the qubit $T_1$ through the resonator:

$$\frac{1}{T_1^{\text{Purcell}}} = \kappa\left(\frac{g}{\Delta}\right)^2 = \kappa \cdot \frac{\chi}{\Delta}$$

For our parameters: $1/T_1^{\text{Purcell}} = 2\pi \times 10^6 \times (100 \times 10^6 / 2 \times 10^9)^2 = 2\pi \times 2.5$ kHz, giving $T_1^{\text{Purcell}} \approx 64\ \mu\text{s}$. If $T_1$ from other sources is 200 $\mu\text{s}$, the Purcell limit reduces it to $T_1^{\text{eff}} = (1/64 + 1/200)^{-1} \approx 48\ \mu\text{s}$. A Purcell filter can suppress this by a factor of 10, restoring $T_1$ to $\sim$130 $\mu\text{s}$.

29.10.2 Multiplexed Readout

For multi-qubit processors, readout multiplexing allows measuring multiple qubits with a single feedline. Each qubit's readout resonator is designed with a different frequency, and the readout tones are frequency-multiplexed. A broadband TWPA amplifies all frequencies simultaneously, and the digitizer separates the signals using digital downconversion.

The number of qubits that can be multiplexed on a single feedline is limited by: 1. Resonator bandwidth: Each resonator occupies $\sim 2\kappa$ of bandwidth. For $\kappa/2\pi = 2$ MHz, 10 qubits need $\sim 40$ MHz, well within a typical TWPA bandwidth of 3–8 GHz. 2. Crosstalk: Readout tones for one qubit can affect neighboring resonators. Frequency spacing of $>5\kappa$ minimizes this. 3. Dynamic range: The TWPA and HEMT must not saturate when amplifying all tones simultaneously. The total power must stay below the TWPA's 1 dB compression point ($\sim -110$ dBm).

Modern processors multiplex 4–8 qubits per feedline, with 4 feedlines per DR for a total of 16–32 qubits per DR.

29.10.3 Quantum-Limited Amplification

The quantum limit for a phase-preserving amplifier is:

$$T_N \geq \frac{\hbar\omega}{2k_B}$$

This is the standard quantum limit (SQL), corresponding to half a photon of added noise. At 5 GHz, the SQL is $T_N^{SQL} = \hbar\omega/(2k_B) = 120$ mK. A HEMT amplifier at 4 K has $T_N \sim 5$ K, which is $\sim 40\times$ the SQL. A JPA or TWPA at 15 mK can approach $T_N \sim 200$ mK, which is only $\sim 1.7\times$ the SQL — near-quantum-limited amplification.

The improvement in readout fidelity from quantum-limited amplification is dramatic. Without a JPA/TWPA:

$$\text{SNR}_{\text{no-JPA}} = \frac{n_{\text{photons}} \cdot \chi}{k_B T_N / \hbar\omega} \propto n_{\text{photons}} / T_N^{HEMT}$$

With a near-quantum-limited TWPA:

$$\text{SNR}_{\text{with-TWPA}} = \frac{n_{\text{photons}} \cdot \chi}{k_B T_N^{TWPA} / \hbar\omega} \propto n_{\text{photons}} / T_N^{SQL}$$

The SNR improvement is $T_N^{HEMT} / T_N^{TWPA} \sim 25$, which translates to a $\sqrt{25} = 5\times$ improvement in readout fidelity per measurement shot, or a $25\times$ reduction in the number of shots needed for the same fidelity.

29.11 Chip Fabrication and Packaging

29.11.1 Transmon Fabrication

A transmon qubit is fabricated on a silicon or sapphire substrate using standard thin-film lithography:

1. Substrate preparation: High-resistivity (>10 k$\Omega$·cm) silicon or sapphire, cleaned and prepared with a hydrofluoric acid dip to remove native oxide.
2. Thin film deposition: A 100–150 nm film of niobium or aluminum is deposited by sputtering or evaporation. Niobium has higher critical temperature ($T_c = 9.2$ K) and lower loss, while aluminum ($T_c = 1.2$ K) is easier to work with.
3. Lithography: The circuit pattern is defined by electron-beam lithography (for research chips) or deep-UV lithography (for production chips). The minimum feature size is $\sim 100$ nm for Josephson junctions.
4. Josephson junction formation: The Josephson junction is created by double-angle evaporation of aluminum through a suspended resist mask (Dolan bridge technique). A thin oxide barrier ($\sim 1$–2 nm of AlO$_x$) separates the two aluminum layers.
5. Lift-off: The resist is dissolved, leaving the patterned superconducting circuit.

The entire process takes 1–2 weeks for a research chip, or 1–2 days for a production chip using steppers instead of e-beam writers.

29.11.2 Packaging and Wire Bonding

The fabricated chip is wire-bonded to a printed circuit board (PCB) that provides the interface to the cryogenic wiring. Key considerations:

• Material compatibility: The PCB must have low dielectric loss at cryogenic temperatures. RT/duroid 5880 ($\tan\delta \sim 10^{-4}$ at 4 K) or sapphire substrates are commonly used.
• Wire bonding: 25 $\mu$m aluminum or gold wires connect the chip pads to the PCB. Each qubit requires 2–4 wire bonds for drive and readout. A 100-qubit chip has 400+ wire bonds.
• Flip-chip bonding: In advanced packaging, the qubit chip is flip-chip bonded to an interposer chip that provides readout resonators and Purcell filters. This reduces the wire bond count and improves microwave performance.

Try It Yourself: Yield Estimation

A transmon chip with 100 qubits has 200 Josephson junctions (2 per transmon), 100 readout resonators, and 100 Purcell filters. If each component has a 99.5% fabrication yield, what is the probability that the entire chip works? (Answer: $0.995^{400} \approx 0.13$ — only 13% yield! This is why yield improvement is critical for scaling.)

29.11.3 3D Integration

For processors with >1000 qubits, 2D wire bonding becomes impractical. 3D integration (also called flip-chip or multi-chip module) separates the qubit layer from the interconnect layer:

1. Qubit chip: Contains the transmon qubits and Josephson junctions
2. Interposer chip: Contains the readout resonators, Purcell filters, and routing
3. Bump bonds: Superconducting indium bump bonds connect the two chips, providing both electrical and mechanical connections

This approach allows each chip to be optimized independently — the qubit chip for coherence, the interposer for microwave performance — and enables repairability: a faulty qubit chip can be replaced without discarding the interposer.

29.12 Software and Calibration Automation

29.12.1 Machine Learning for Calibration

Modern quantum processors use machine learning to automate and optimize calibration:

1. Bayesian optimization: Optimizes gate parameters (frequency, amplitude, duration) by building a probabilistic model of the objective function and selecting the next experiment to maximize information gain.

2. Reinforcement learning: Learns optimal pulse shapes by treating the gate fidelity as a reward signal. The agent explores the pulse parameter space and converges on pulses that maximize fidelity.

3. Gaussian process regression: Models qubit parameter drift (frequency, $T_1$, $T_2$) as a function of time, enabling predictive recalibration. Instead of measuring every qubit every hour, the system predicts which qubits need recalibration based on their drift history.

4. Neural network-based state discrimination: Replaces linear discriminant analysis with a small neural network that can learn complex IQ distributions and handle drift in the readout.

These techniques reduce calibration time from hours to minutes, enabling continuous operation of large-scale quantum processors.

29.12.2 Qiskit Runtime and Serverless Execution

Qiskit Runtime is IBM's execution model that moves the classical computation closer to the quantum processor. Instead of submitting individual circuits and waiting for results, users submit an entire program (including classical processing) that runs on a server near the quantum processor:

Traditional Model:
  User → Quantum Circuit → Cloud → Quantum Processor → Cloud → User → Classical → Repeat

Qiskit Runtime Model:
  User → Program → Runtime Server (near QP) → [Execute + Process] → Results

  Advantage: ~100× reduction in latency for variational algorithms

For variational algorithms like VQE and QAOA, the iterative classical optimization loop runs near the quantum processor, eliminating the round-trip latency to the user's computer. This reduces the time per iteration from seconds to milliseconds — a critical improvement for algorithms that require thousands of iterations.

29.13 Quantum Error Correction at the System Level

29.13.1 The Surface Code on Real Hardware

The surface code is the leading candidate for quantum error correction on superconducting processors. Google's 2023 demonstration of a logical qubit with the surface code showed:

• Physical qubits: 72 transmon qubits arranged in a 2D grid
• Code distance: $d = 3$ (9 data qubits, 8 measure qubits, 55 ancilla qubits)
• Logical error rate: $10^{-3}$ per correction cycle
• Key result: The logical error rate decreased as code distance increased from $d = 3$ to $d = 5$, confirming that error correction works

The system-level requirements for surface code error correction are:

1. Two-qubit gate fidelity: Must exceed the threshold (~1% for the surface code, but >99% in practice for reasonable overhead)
2. Measurement fidelity: Must be >99% for syndrome extraction
3. Measurement latency: Must be <1 $\mu$s for real-time decoding
4. Classical decoding: Must process syndromes at the same rate as they are generated

The classical decoding problem is often overlooked but is critical: a distance-$d$ surface code on $2d^2$ qubits generates $d^2 - 1$ syndrome measurements per cycle, and the decoder must process these in $<1\ \mu\text{s}$ to keep up with the quantum hardware. For $d = 33$ (the distance needed for 99.9% logical fidelity with 99.9% physical fidelity), this means processing ~1000 syndromes in 1 $\mu\text{s}$ — a challenging but feasible task for modern FPGAs.

29.13.2 Cryogenic Classical Control

A major scalability bottleneck is the wiring between room-temperature control electronics and the millikelvin qubits. Each qubit requires 2-4 coaxial lines, and a 1000-qubit processor would need 2000-4000 lines — exceeding the thermal budget and physical space of current dilution refrigerators.

Cryogenic CMOS controllers operating at 4 K can address this bottleneck by:

1. Multiplexing multiple qubit control signals onto a single room-temperature line
2. Performing real-time signal processing (frequency multiplexing, digital-to-analog conversion) at 4 K
3. Reducing the number of room-temperature-to-4K coaxial lines by 10-100×

Intel's Horse Ridge II chip (2021) demonstrated cryogenic CMOS control of multiple qubits at 4 K, achieving:

• Frequency multiplexing: 8 qubits per control line
• Power consumption: <2 mW at 4 K (within the cooling budget)
• Operating temperature: 4 K (achievable with pulse tube coolers)

This is an active area of research, with several groups (Google, Intel, IBM, Microsoft) developing cryogenic control chips for next-generation quantum processors.

29.13.3 The Cost of Error Correction

The resource overhead for surface code error correction is substantial. For a logical qubit with error rate $p_L$, the required code distance is approximately:

$$d \approx 2\left\lceil \frac{\log(p_L / p_{\text{physical}})}{2\log(p_{\text{th}} / p_{\text{physical}})} \right\rceil + 1$$

For $p_{\text{physical}} = 10^{-3}$, $p_{\text{th}} = 10^{-2}$, and $p_L = 10^{-10}$ (needed for factoring RSA-2048):

$$d \approx 2\left\lceil \frac{\log(10^{-10} / 10^{-3})}{2\log(10^{-2} / 10^{-3})} \right\rceil + 1 = 2\left\lceil \frac{7}{2} \right\rceil + 1 = 15$$

A distance-15 surface code requires $2d^2 = 450$ physical qubits per logical qubit. For 4,000 logical qubits (needed for RSA-2048), this is 1.8 million physical qubits — roughly consistent with the 20 million estimate that includes ancilla qubits and routing overhead.

Worked Example 29.4: Error Correction Overhead

Compare the overhead for surface code error correction at different physical gate fidelities:

Improving physical gate fidelity from 99% to 99.9% reduces the overhead by ~5×. From 99.9% to 99.99%, another ~4.5×. This is why gate fidelity is the most important metric — every factor of 10 improvement in gate fidelity reduces the qubit overhead by a factor of ~4-5.

29.14 Industry Landscape

29.14.1 Major Quantum Computing Companies

29.14.2 National Quantum Programs

Governments worldwide are investing heavily in quantum computing:

• USA: National Quantum Initiative Act (\$1.2B over 5 years, 2019-2024); CHIPS and Science Act (\$10B for quantum and AI)
• EU: Quantum Flagship (\$1.1B over 10 years, 2018-2028)
• China: Estimated \$15B+ in total quantum investment; world's longest QKD network (2,000+ km)
• UK: National Quantum Computing Centre (\$500M); National Quantum Technology Programme
• Japan: Moonshot R&D Program (\$600M for quantum)
• Canada: National Quantum Strategy (\$360M)

The global investment in quantum computing exceeds \$30B as of 2024, with the majority going to hardware development and workforce training.