Superconducting Quantum Computing for Electrical Engineers

1. Introduction: Why Should an Electrical Engineer Care About Quantum Computing?

Imagine running a Fast Fourier Transform on a dataset so large that classical computers would take longer than the age of the universe to complete it, yet a quantum computer could solve it in seconds. Imagine EDA tools that can optimize billion-transistor chip layouts by exploring all possible configurations simultaneously, rather than relying on heuristics. Imagine protein folding simulations that unlock CRISPR-based cancer therapies, or physics simulations that reveal new materials for room-temperature superconductors. These are not science fiction; they are the promises of fault-tolerant quantum computing, and they are closer than most people realize.

The catch? We are not there yet. Today's quantum computers are fragile, error-prone, and limited to a few hundred qubits. The path from laboratory curiosities to world-changing machines requires solving numerous engineering challenges, and many of these challenges are fundamentally electrical engineering problems: RF pulse generation with sub-nanosecond timing, cryogenic low-noise amplification at the quantum limit, high-speed digital signal processing for real-time error correction, and feedback control systems that operate faster than qubits can decohere. This is where EEs come in. The quantum computing revolution will not be led by physicists alone; it needs engineers who understand signal integrity, noise floors, and system integration. The field is wide open, and the opportunities for impact are immense.

This document presents quantum computing from an EE perspective, translating quantum mechanical concepts into familiar circuit and signal processing terminology. The goal is to provide sufficient background for EE researchers to contribute meaningfully to quantum computing hardware development without requiring an extensive physics background.

1.1 The Quantum Computing Stack

A superconducting quantum computer consists of several layers, most of which involve traditional EE disciplines:

This document focuses on the physics necessary to understand the signal processing layer, with particular attention to the readout discrimination problem.

1.2 Where Does Quantum Speedup Come From?

Before diving into hardware details, it is worth understanding why quantum computers can outperform classical computers for certain problems. The answer is subtle and often misunderstood.

1.2.1 The Naive (Wrong) Explanation

A common misconception is: "A qubit can be 0 and 1 simultaneously, so \(n\) qubits can represent \(2^n\) states at once, giving exponential parallelism." This is misleading because:

• While \(n\) qubits can exist in a superposition of \(2^n\) basis states, measurement only returns one outcome
• If superposition alone provided speedup, we could just flip \(n\) coins and call it parallel computation
• The speedup comes from something more subtle: interference

Why the Misconception Seems Plausible: The naive explanation feels right because quantum operations are linear. If you apply a function \(f\) to a superposition, you get the superposition of the outputs:

\(f(|0\rangle + |1\rangle) = f(|0\rangle) + f(|1\rangle)\)

This makes qubits look like "variables" in a program that can hold multiple values at once. If \(f\) is expensive to compute classically, it seems like we could evaluate it on all inputs in parallel. This is exactly what happens during the computation. The problem is that when we measure, we get one random output, not all of them. The "parallel computation" did happen, but we can only see one result. Without interference to bias which result we see, we have gained nothing over random guessing.

1.2.2 The Correct Explanation: Interference

Quantum algorithms exploit the wave-like nature of quantum states. In a superposition:

the amplitudes \(\alpha_x\) are complex numbers that can interfere constructively or destructively when the quantum state evolves. A well-designed quantum algorithm:

1. Prepares a superposition over all possible inputs (easy; a few Hadamard gates)
2. Applies operations that encode the problem structure into the amplitudes
3. Engineers interference so that "wrong" answers have amplitudes that cancel out, and "right" answers have amplitudes that add up
4. Measures to obtain a right answer with high probability

How Interference Is Engineered: The key insight is that quantum gates manipulate phases, not just probabilities. Consider a simple example with two paths to the same answer:

• Path A contributes amplitude \(+0.5\) to answer \(|x\rangle\)
• Path B contributes amplitude \(+0.5\) to answer \(|x\rangle\)
• Total amplitude: \(0.5 + 0.5 = 1.0\), so probability \(= |1.0|^2 = 1\) (certain)

Now consider a wrong answer where the phases differ:

• Path A contributes amplitude \(+0.5\) to answer \(|y\rangle\)
• Path B contributes amplitude \(-0.5\) to answer \(|y\rangle\)
• Total amplitude: \(0.5 + (-0.5) = 0\), so probability \(= |0|^2 = 0\) (impossible)

The algorithm designer's job is to construct a sequence of gates such that, after all operations complete, the wrong answers have uniformly distributed phases (they cancel when summed) while correct answers are in phase (they add constructively). This is not magic; it requires deep mathematical structure in the problem. Factoring integers has this structure; sorting a list does not.

Seeing Interference in Action: For readers who want to visualize this process, interactive quantum circuit simulators provide immediate feedback:

• Quirk (https://algassert.com/quirk): Drag-and-drop circuit builder that shows amplitude magnitudes and phases in real time. Try building a 2-qubit Grover's algorithm to watch amplitudes redistribute.
• IBM Quantum Composer (https://quantum.ibm.com/composer): Build circuits and run them on real quantum hardware. Observe how measurement statistics match theoretical predictions.

1.2.3 Quantum Logic Gates: How Operations Work

Quantum algorithms are built from quantum gates, which transform qubit states. Unlike classical gates (AND, OR, NOT), quantum gates must be unitary: reversible and norm-preserving. This section introduces the essential gates.

Single-Qubit Gates: A single-qubit gate is a \(2 \times 2\) unitary matrix acting on the qubit state vector \([\alpha, \beta]^T\). The most important gates are:

• X Gate (NOT): Flips \(|0\rangle \leftrightarrow |1\rangle\). Matrix: \(X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\)
• Z Gate (Phase Flip): Leaves \(|0\rangle\) unchanged, flips the sign of \(|1\rangle\). Matrix: \(Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}\)
• Hadamard Gate (H): Creates superposition from basis states. \(H|0\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)\), \(H|1\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle)\). Matrix: \(H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\)

On the Bloch sphere (Section 2), gates correspond to rotations: X rotates about the x-axis, Z rotates about the z-axis, and H rotates to the equator.

Two-Qubit Gates and Entanglement: The CNOT (Controlled-NOT) gate is the essential two-qubit gate. It flips the "target" qubit if and only if the "control" qubit is \(|1\rangle\):

The CNOT gate creates entanglement when applied to a superposition. Starting from \(|00\rangle\):

1. Apply H to qubit 1: \(H|0\rangle \otimes |0\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle) \otimes |0\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)\)
2. Apply CNOT (qubit 1 controls qubit 2): \(\frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)\)

The result is a Bell state: the two qubits are correlated such that measuring one instantly determines the other, regardless of distance. This is not classical correlation (the qubits were not "secretly" in a definite state). Entanglement is a uniquely quantum resource exploited by algorithms and error correction.

1.2.4 Examples of Quantum Speedup

Well-known quantum algorithms and their speedups are summarized below. Each algorithm exploits a different type of mathematical structure.

*HHL speedup comes with significant caveats about input/output encoding.

What Each Algorithm Does:

Shor's Algorithm: Factors large integers by exploiting periodicity in modular exponentiation. This breaks RSA encryption, which relies on the difficulty of factoring products of large primes. A sufficiently large quantum computer could break most of today's public-key cryptography.

Grover's Algorithm: Searches an unsorted database of \(N\) items in \(O(\sqrt{N})\) time instead of \(O(N)\). This is "only" a quadratic speedup (not exponential), but it is provably optimal for unstructured search. It also applies to any NP problem: if verifying a solution takes time \(T\), Grover's can find one in \(O(\sqrt{N} \cdot T)\) time.

Quantum Simulation: Simulates quantum systems (molecules, materials, chemical reactions) efficiently. Classical computers struggle because simulating \(n\) quantum particles requires tracking \(2^n\) amplitudes. Quantum computers represent these states natively. Applications include drug discovery, materials science, and understanding high-temperature superconductivity.

HHL Algorithm: Solves systems of linear equations \(Ax = b\) exponentially faster than classical methods, with applications to machine learning and optimization. However, the speedup requires quantum-native input/output: preparing the input state and reading out the result both have overhead that can erase the advantage for many practical problems.

1.2.5 What Quantum Computers Cannot Do

Quantum computers are not universal replacements for classical computers. Several fundamental limitations prevent QC from being "faster at everything":

1. Measurement destroys information: After measurement, superposition collapses to a single outcome. You cannot extract all \(2^n\) computed values; you get one.
2. No structure, no speedup: Quantum algorithms require mathematical structure (periodicity, symmetry, phase patterns) to engineer interference. Most problems lack this structure.
3. Input/output bottleneck: Loading classical data into a quantum state and extracting results both require time proportional to data size. For problems dominated by I/O, quantum offers no advantage.
4. Error correction overhead: Fault-tolerant quantum computing requires 100-1000 physical qubits per logical qubit. A "1000-qubit" quantum computer may have only 1-10 logical qubits.

1.2.6 Why Readout Matters for Speedup

The interference patterns that encode the answer are fragile. They exist in the complex amplitudes \(\alpha_x\), which we cannot directly observe. We can only measure, which collapses the superposition and returns a single outcome. If the algorithm worked correctly, that outcome is (probably) the right answer. But there are failure modes:

• Decoherence during computation: If the coherence time T2 is too short (see Section 8 for formal definition), the interference pattern degrades before we finish the algorithm
• Gate errors: Imperfect gates corrupt the amplitudes, causing wrong answers to gain probability
• Readout errors: Even if the qubit is in the right state, misclassification reports the wrong answer

This is why high-fidelity readout is essential. The quantum computation may have produced the correct answer, but a readout error at the final step throws it away. For algorithms requiring many measurements (like variational algorithms), readout errors compound across shots. For quantum error correction, readout errors can be mistaken for data errors, triggering incorrect corrections.

2. The Transmon Qubit: A Nonlinear LC Oscillator

Quantum computation requires a physical system with exactly two accessible energy levels: a qubit. Why build one from an oscillator? Because quantum harmonic oscillators are among the best-understood quantum systems, they can be manufactured with existing microwave technology, and they couple naturally to electromagnetic control fields. The challenge is that a linear oscillator has infinitely many evenly-spaced energy levels, not two. The transmon solves this by introducing nonlinearity via a Josephson junction, creating unequal energy spacing that allows selective addressing of just the lowest two levels.

This section explains why linear oscillators fail as qubits, how the Josephson junction provides the necessary nonlinearity, and how the transmon circuit realizes a practical qubit. Understanding this circuit is essential for the readout discussion in later sections.

2.1 The Problem with Linear LC Circuits

Consider a standard LC oscillator. When quantized (treated quantum mechanically), its energy levels are:

This is the quantum harmonic oscillator [8], with evenly spaced energy levels separated by \(\hbar\omega\). The transition frequency between any two adjacent levels is identical:

2.2 The Josephson Junction Solution

The solution is to replace the linear inductor with a Josephson junction [4], which acts as a nonlinear inductor. The junction's inductance depends on the current flowing through it:

This nonlinear inductance creates a cosine potential instead of the quadratic potential of a linear inductor. The energy stored in the junction is:

The cosine potential has a different curvature than a parabola, leading to unequally spaced energy levels:

The parameter \(\alpha\) is called the anharmonicity [10]. It represents the frequency difference between adjacent transitions. With \(\alpha \approx 200\) MHz, we can send a ~20 ns pulse (bandwidth ~50 MHz) that drives \(|0\rangle\leftrightarrow|1\rangle\) without significantly exciting \(|1\rangle\rightarrow|2\rangle\).

2.3 The Transmon Circuit

The transmon [10] (transmission-line shunted plasma oscillation qubit) is the most common superconducting qubit design. At its core, it consists of a Josephson junction shunted by a large capacitor—but physical implementations reveal a rich hierarchical structure spanning three orders of magnitude in scale.

Fig. 1: Multi-scale view of a transmon qubit: (a) Full transmon with cross-shaped capacitor pads and SQUID at center (100 μm scale), (b) SQUID detail showing two Josephson junctions in a loop (10 μm scale), (c) Single Josephson junction (200 nm scale). Circuit symbols shown below each image. Image from [47].

Modern transmons typically use a SQUID (Superconducting Quantum Interference Device)—two Josephson junctions in a superconducting loop—rather than a single junction. This allows in-situ tuning of the effective Josephson energy via an external magnetic flux threading the loop. The large cross-shaped pads visible in panel (a) form the shunt capacitor \(C_s\); their geometry is carefully designed to minimize surface losses while providing the required capacitance (~80 fF) for operation in the transmon regime.

Fig. 2: Physical qubit architecture and circuit representation (SQMS fabrication). (a) 8-qubit chip for testing three distinct qubit geometries; signals enter via 50 Ω launchers on flux line. (b) False-colored single qubit: niobium-tantalum encapsulated pads (orange) form capacitors for the Josephson junction on sapphire substrate. (c) Zoomed junction region (20 μm). (d) SEM image of Josephson junction: aluminum superconductors separated by aluminum oxide barrier. (e) Resonator capacitively coupled to flux line. (f) Coupling dimensions. (g) Circuit diagram.

Physical Architecture Details:

The chip in Fig. 2(a) contains eight qubits arranged to test different capacitor geometries. Each qubit is coupled to a coplanar waveguide (CPW) resonator, visible as the meandering transmission line in panel (e), which serves as the primary interface for both control and readout.

50 Ω Launchers and Chip I/O: The rectangular pads at the left and right sides of the chip are 50 Ω launchers: impedance-matched transitions that connect the on-chip transmission lines to external microwave electronics. Gold or aluminum wirebonds connect these launchers to a printed circuit board (PCB) mounted in the cryostat. The 50 Ω characteristic impedance matches standard microwave test equipment, which minimizes signal reflections that would otherwise distort pulses and corrupt readout signals.

Feedline Architecture and Frequency Multiplexing: A central feedline (visible running horizontally across the chip) acts as a shared microwave highway. Multiple readout resonators, each tuned to a different frequency, couple capacitively to this feedline. This architecture enables frequency-division multiplexing: a single input/output line can address many qubits simultaneously by sending microwave tones at each resonator's unique frequency. Adjacent resonators are typically spaced 50-100 MHz apart to prevent crosstalk [12].

Qubit-Resonator Coupling: Each qubit couples to its dedicated resonator through a small coupling capacitor \(C_g\). The coupling strength \(g/2\pi \sim 50\text{-}100\) MHz is carefully engineered: strong enough for fast readout, but weak enough to operate in the dispersive regime where the qubit-resonator detuning \(\Delta = \omega_q - \omega_r\) satisfies \(|\Delta| \gg g\).

Signal Flow:

Readout: A microwave tone near the resonator frequency enters through one launcher, travels along the feedline, and interacts with each resonator it passes. The transmitted (or reflected) signal carries phase and amplitude information encoding the qubit states, then exits through the opposite launcher to be amplified and digitized.

Control: Qubit drive pulses at the qubit frequency \(f_{01}\) also enter through the feedline. Although primarily intended for readout, the resonator acts as a bandpass filter that couples control pulses to the qubit while providing Purcell filtering, which suppresses qubit energy decay into the feedline at frequencies far from the resonator.

Materials Engineering: Achieving long coherence times requires careful materials selection. The SQMS design uses:

• Sapphire substrate: Low-loss dielectric (\(\tan\delta < 10^{-6}\)) with excellent thermal conductivity at millikelvin temperatures
• Niobium-tantalum encapsulation: Protects niobium surfaces from native oxide formation, reducing two-level system (TLS) defects that limit \(T_1\) [27]
• Aluminum Josephson junctions: Standard Al/AlO\(_x\)/Al trilayer fabricated via double-angle evaporation, with junction area ~200 nm × 200 nm setting \(E_J\)

3. Cooper Pairs and the Josephson Effect

This section explains the physics underlying the Josephson junction. For readers primarily interested in signal processing applications, this section can be skimmed; the key result is Equation (4).

3.1 Why Superconductors Are Different

At temperatures below the critical temperature \(T_c\) (about 1.2 K for aluminum) [6], electrons in a metal form bound pairs called Cooper pairs [5]. This pairing is mediated by phonons (lattice vibrations):

1. An electron moving through the lattice attracts nearby positive ions
2. This creates a region of slightly higher positive charge density
3. A second electron is attracted to this region
4. The two electrons become weakly bound (binding energy ~0.1-1 meV)

The key difference is that Cooper pairs are bosons. Because bosons are not subject to the Pauli exclusion principle, they can all condense into the same quantum ground state [6]. This Bose-Einstein condensate is described by a single macroscopic wavefunction:

3.2 Quantum Tunneling

Quantum tunneling [8] is not unique to Cooper pairs; it occurs for any quantum particle. The key physics is that a particle's wavefunction does not stop at a potential barrier but decays exponentially inside it:

If the barrier is thin enough (~1 nm for a Josephson junction), the wavefunction has non-zero amplitude on the other side, giving a finite tunneling probability:

Single electrons tunnel through thin insulators routinely (this is how scanning tunneling microscopes and flash memory work). What makes Josephson tunneling special is that Cooper pairs tunnel coherently (preserving phase information) and dissipationlessly (no energy loss).

3.3 The Josephson Equations

When two superconductors are separated by a thin insulator, Cooper pairs can tunnel between them [4]. The tunneling current depends on the phase difference \(\delta = \phi_L - \phi_R\):

The phase evolves according to the voltage across the junction:

3.4 Why Josephson Tunneling is Dissipationless

In a superconductor, there is an energy gap \(\Delta\) (~0.2 meV for aluminum). To create a quasiparticle excitation (break a Cooper pair), energy \(2\Delta\) is required. For voltages \(V < 2\Delta/e \approx 0.4\) mV:

• Not enough energy to break Cooper pairs
• No quasiparticle current (which would be dissipative)
• Only coherent Cooper pair tunneling occurs
• Zero resistance (supercurrent)

Qubits always operate in this sub-gap regime, ensuring dissipationless dynamics.

3.5 Visualizing Qubit States: Bloch Sphere and Wigner Function

Before moving to measurement, it is worth briefly noting how qubit states are typically visualized.

The Bloch Sphere: Any pure state of a two-level quantum system (qubit) can be written as:

This parameterization maps qubit states to points on a unit sphere called the Bloch sphere [7]. The north pole represents \(|0\rangle\), the south pole represents \(|1\rangle\), and points on the equator represent equal superpositions with different phases.

The Wigner Function: The Wigner function \(W(x, p)\) is a quasi-probability distribution that represents quantum states in phase space. Unlike classical probability distributions, the Wigner function can take negative values, which is a signature of non-classical behavior.

Why Wigner Negativity Matters in Quantum Computing:

• Hudson's Theorem: A pure quantum state has a non-negative Wigner function if and only if it is Gaussian. Any non-Gaussian state must have negative regions.
• Quantum vs. Classical: A positive Wigner function can be interpreted as a classical probability distribution. Negativity proves that no such classical description exists.
• Computational Resource: In bosonic quantum computing, Wigner negativity is a resource for quantum advantage.

4. Qubit State Measurement: Dispersive Readout

Measuring a qubit state is fundamentally an RF engineering problem. This section describes the standard approach used in nearly all superconducting quantum computers.

4.1 The Dispersive Regime

The qubit is capacitively coupled to a readout resonator (a linear microwave cavity, typically ~7 GHz). When the qubit and resonator frequencies are far detuned (\(|\omega_q - \omega_r| \gg g\), where \(g\) is the coupling strength), the system is in the dispersive regime [9,12].

In this regime, the resonator frequency depends on the qubit state:

4.2 The Measurement Process

To measure the qubit, we probe the resonator with a microwave tone and detect the state-dependent phase/amplitude shift:

1. Send probe tone at frequency near \(f_r\)
2. Signal reflects off resonator with state-dependent phase:
   • Qubit in \(|0\rangle\): resonator at \(f_r + \chi\) → phase \(\phi_0\)
   • Qubit in \(|1\rangle\): resonator at \(f_r - \chi\) → phase \(\phi_1\)
3. Amplify using cryogenic amplifier (HEMT or JPA/TWPA)
4. Downconvert to intermediate frequency (~100 MHz)
5. Digitize I and Q quadratures
6. Classify in IQ plane to determine state

4.3 The IQ Plane Representation

After digitization, each readout pulse produces a point in the IQ plane. Due to the dispersive shift, \(|0\rangle\) and \(|1\rangle\) states produce points clustered in different regions.

Fig. 3: Qubit state discrimination in the IQ plane from actual experimental data. Each dot represents a single-shot readout measurement: red points correspond to the ground state \(|0\rangle\), blue points to the excited state \(|1\rangle\). The dashed line shows the optimal linear decision boundary for state classification.

What the Clusters Tell Us:

• Cluster separation is proportional to the dispersive shift \(\chi\) and integration time \(\tau\). The total separation scales as \(2\chi\tau\).
• Cluster width reflects the total system noise, combining thermal fluctuations, amplifier noise, and any other broadening mechanisms.

The signal-to-noise ratio for state discrimination is simply:

4.4 Sources of Readout Error

The fundamental tradeoff is between integration time and T1 decay:

• Longer integration → more signal → higher SNR
• But longer integration → more time for \(|1\rangle\rightarrow|0\rangle\) decay → measure wrong state
• Optimal readout time is typically 100-500 ns

4.5 From Superposition to Definite Outcomes: How Measurement Works

A fundamental question arises: if a qubit can exist in a superposition of \(|0\rangle\) and \(|1\rangle\), how do we ever get a definite answer?

The Measurement Postulate: In quantum mechanics, measurement is fundamentally different from classical observation [7]. When we measure a qubit in the state:

The measurement does not reveal "a little bit of \(|0\rangle\) and a little bit of \(|1\rangle\)." Instead:

• We get exactly \(|0\rangle\) with probability \(|\alpha|^2\)
• We get exactly \(|1\rangle\) with probability \(|\beta|^2\)
• The superposition is destroyed (this is called "wavefunction collapse")
• After measurement, the qubit is in whichever state we measured

Readout Fidelity Calculation:

The Role of Statistics: Because each measurement gives a probabilistic outcome, quantum computing fundamentally requires statistics. The number of shots required depends on the desired precision:

5. The Readout Signal Processing Challenge

5.1 The Ensemble Averaging Approach

The traditional approach to improving measurement SNR is ensemble averaging: repeat the experiment \(N\) times and average the results. The SNR improvement scales as:

For example, to improve SNR by 10× requires 100 repetitions.

5.2 The Single-Shot Requirement

Many quantum computing applications require single-shot readout, where each individual measurement must correctly identify the qubit state.

For quantum error correction using the surface code, single-shot readout fidelity must exceed ~99% to remain below the error threshold [11].

5.3 Optimal Filtering: The Signal Processing Solution

Rather than averaging multiple experiments, we can apply optimal filtering to a single readout pulse. The key insight is that not all time samples are equally informative:

• Early samples contain mostly noise (resonator hasn't responded yet)
• Late samples may be corrupted by T1 decay
• The optimal filter weights samples according to their information content

The Wiener filter provides the theoretically optimal linear filter for minimizing mean-squared error in Gaussian noise:

In RTL simulation, a 64-tap filter provides +9 dB improvement, equivalent to the SNR gain from 64× ensemble averaging, but achieved in a single shot.

6. Control Electronics: The QICK Platform

The Quantum Instrumentation Control Kit (QICK) is an open-source qubit control platform developed at Fermilab [14]. It provides the classical electronics interface for superconducting quantum computers, representing a paradigm shift from traditional rack-mounted instrumentation to integrated FPGA-based control.

6.1 System Architecture

Fig. 4: QICK system architecture showing the complete signal path from user software to qubits. Software Block (left): PYNQ provides the Python interface. Processing System (right, top): The RFSoC's ARM processors handle experiment orchestration. Programmable Logic (right, middle): RF-ADCs and RF-DACs interface directly with custom signal processing blocks. RF Board and Cryogenics (bottom): Analog signals travel to/from the dilution refrigerator containing the qubits.

Why FPGAs Instead of Traditional Instrumentation?

Traditional qubit control systems rely on stacks of commercial arbitrary waveform generators (AWGs), local oscillators, mixers, and digitizers—often filling entire equipment racks for a single qubit [15]. This approach has several limitations:

• Cost: Commercial AWGs capable of direct microwave synthesis cost $50,000-$200,000 per channel
• Synchronization: Coordinating timing across multiple instruments introduces jitter and complexity
• Latency: Communication between rack instruments and control computers adds microseconds of delay
• Scalability: Adding qubits requires proportionally more equipment

RFSoC FPGAs address these challenges by integrating high-speed data converters directly with programmable logic on a single chip.

6.2 QICK Firmware Architecture

The QICK firmware is built around three core components: the tProcessor (tProc) for timing control, the signal generator (SG) blocks for pulse synthesis, and the readout blocks for signal acquisition and processing.

Fig. 5: QICK Version 1 firmware architecture. Top left: System overview showing the PS/PL boundary. Top right: Single DAC output signal generator detail. Bottom right: 64-bit tProcessor V1 block diagram.

Fig. 6: QICK Version 2 firmware architecture. Top left: System overview. Top right: Frequency-multiplexed DAC output. Bottom left: Multiplexed readout process with polyphase filter bank. Bottom right: 72-bit tProcessor V2 block diagram built on RISC architecture.

Key Improvements in V2:

• RISC architecture: The 72-bit tProc V2 uses a pipelined RISC design, improving instruction throughput
• Polyphase filter bank: Enables simultaneous processing of up to 16 frequency-multiplexed readout channels
• Frequency-multiplexed output: Multiple tones can be generated on a single DAC channel
• Enhanced memory architecture: Separate memories with dual-port access for concurrent read/write

6.3 The tProcessor: Timing and Synchronization

The tProcessor (timed processor) is QICK's solution for deterministic, cycle-accurate control:

7. The Current State of Quantum Computing

7.1 NISQ, FTQC, and FASQ

7.2 The Error Budget

7.3 Why Readout Matters for Error Correction

Quantum error correction (QEC) works by encoding a single logical qubit in many physical qubits and repeatedly measuring "syndrome" qubits to detect errors. For the surface code:

• Syndrome measurements must complete in ~1 μs (before errors accumulate)
• Each syndrome measurement requires single-shot readout
• Readout errors can be mistaken for data errors, causing incorrect corrections
• The error correction threshold requires physical error rates below ~1%

8. Qubit Performance Metrics and Platform Comparison

8.1 Key Qubit Metrics

T1: Energy Relaxation Time

T1 measures how long a qubit remains in the excited state \(|1\rangle\) before spontaneously decaying to the ground state \(|0\rangle\):

T2: Dephasing (Coherence) Time

T2 measures how long a qubit maintains phase coherence in a superposition state:

Fig. 7: Bloch sphere visualization of decoherence mechanisms. (a) T1 relaxation: The qubit state decays along the z-axis from \(|1\rangle\) toward \(|0\rangle\). (b) T2 dephasing: A superposition state on the equator loses phase coherence.

Rabi Oscillation and Gate Time:

Gate Fidelity:

Quantitative Scaling Example:

8.2 Quantum Computing Platform Comparison

8.3 SQMS Contributions to Coherence

The Superconducting Quantum Materials and Systems (SQMS) Center at Fermilab has made significant contributions to extending qubit coherence through materials science innovations [27]:

Surface Encapsulation Technique: SQMS researchers identified the niobium surface oxide as the primary source of energy loss in transmon qubits. Their surface encapsulation technique prevents the formation of lossy niobium oxide.

3D SRF Cavity Architecture: SQMS leverages Fermilab's expertise in superconducting radio-frequency (SRF) cavities from particle accelerator development:

• Cavity photon lifetimes exceeding 2 seconds demonstrated
• Two-qudit QPU with >20 ms coherence (record for multimode superconducting system)
• Qudit encoding: single cavity stores multiple quantum levels

9. Application: Adaptive Filtering for Qubit Readout

This section describes how adaptive Wiener filtering [19,20] can address the readout bottleneck described in previous sections.

9.1 The Filtering Approach

9.2 Training and Inference

Training Phase:

1. Prepare qubit in \(|0\rangle\) (ground state, by waiting for T1 decay)
2. Collect many readout pulses → label as class "0"
3. Apply \(\pi\)-pulse to prepare \(|1\rangle\)
4. Collect many readout pulses → label as class "1"
5. LMS algorithm iteratively adjusts filter weights to minimize classification error

Inference Phase:

1. Freeze filter weights (no further adaptation)
2. For each readout pulse, apply fixed weights
3. Output is a single (I, Q) point with improved SNR
4. Classify based on decision boundary

9.3 Performance Summary

10. Mathematical Foundations (Reference)

This section collects the key mathematical results for readers seeking deeper understanding. It can be skipped without loss of continuity.

11. Conclusion

Superconducting quantum computing, despite its quantum mechanical foundations, is largely an electrical engineering endeavor. The qubit is a nonlinear LC oscillator; control and readout involve RF pulse generation and detection; and improving performance requires signal processing techniques familiar to any EE.

The readout bottleneck, in particular, is a classic signal processing problem: discriminating two Gaussian-distributed classes in the presence of noise. Adaptive filtering techniques, long used in communications and radar, can provide significant improvements in single-shot readout fidelity, directly enabling quantum error correction.

For detailed treatment of the adaptive Wiener filter implementation, see the companion document: "Block NLMS Adaptive Wiener Filter for Superconducting Qubit Readout."

References