COE 530 · Spring 2026 · Linking Lecture

From physics to circuits,
and back again.

Closing the gap between what we drive and what we compute.
IBRAHEEM ALYOUSEF
MSc of Quantum Computing · KFUPM
SEMESTER II
§ orientation

Where we are, what's missing.

Two tracks, two semesters. Today they meet — and we look at the seam.
TRACK A · PHYSICS
SEM I · INTRO QM
Linear algebra & states
Superposition, entanglement
Operators & density matrix
Bloch sphere · universal set
No-cloning & teleportation
SEM II · CIRCUIT QED
Lagrangian → Hamiltonian
Circuit quantization
The transmon qubit
Jaynes–Cummings
Dispersive + Rabi
TRACK B · INFO / CS
SEM I · INTRO QC
Complex vectors · states
Deterministic → quantum
Reversible & quantum gates
First algorithms (Deutsch-Jozsa)
Quantum speedup
SEM II · QUANTUM ARCHITECTURE
Digital logic & ISA
Quantum circuits & architecture
Quantum programming
Compilers & benchmarking
Qubit control & measurement ← you are here
02 / 22
§ recap · quantum information theory

The CS track ends just before the machine.

You know how to express an algorithm as a circuit and compile it — but only onto textbook gates. H, X, CNOT. Perfect objects. No hardware.
H
X
CX
Uf
M
// every gate is ideal · every operation is instantaneous · no noise, no time, no frequency
03 / 22
§ recap · physics

The physics track ends just before a circuit.

You can write Hamiltonians, solve Rabi oscillations, derive the dispersive shift. What you can't yet say: which algorithm any of this is running.
DRIVE
Hd = ½ Ω(t) [ σ₊ e−iωdt + h.c. ]
DISPERSIVE
Hdisp = ωr a†a + ½ (ωq + 2χ a†a) σz
// pulses, frequencies, linewidths · but no notion of "a gate"
04 / 22
§ the gap

Two tracks converge. The gap has a name: quantum control.

// quantum control: calibration · native gates · transpilation · pulse synthesis
05 / 22
§ the handshake

The bridge is a handshake between two people.

One runs a chip. One writes circuits. Each speaks their own language — and the handshake is the set of numbers they exchange.
HARDWARE PERSON
"I have one qubit. Here's what I can do to it."
  1. Fabricate & cool the chip
  2. Find the resonator and qubit
  3. Pick a native gate set
  4. Calibrate each gate
  5. Characterize: T₁, T₂*, fidelities
↔
native gates
+ fidelities
⇅
transpiled circuit
ALGORITHM PERSON
"I have a problem. Here's the circuit that solves it."
  1. State the problem
  2. Pick an algorithm
  3. Write the ideal circuit
  4. Optimize (simplify cancellations)
  5. Transpile onto the hardware's native set
Everything that follows is one side of this handshake.
06 / 22
§ workflow

What actually flows across the bridge.

ALGORITHM PERSON HARDWARE PERSON COMPILE TIME DISPATCH RUN TIME POST problem ideal circuit modality native gate set { √X, Rz } calibration tπ/2, χ, T₁, T₂* 1 native set + fidelities HW ⇒ ALGO optimize simplify, cancel transpile onto native set 2 pulse schedule ALGO ⇒ HW pulse synthesis execute + readout raw results 3 results HW ⇒ ALGO bit-strings.
07 / 22
PART I · ALGORITHM-UP

Starting from the
problem.

How a circuit becomes a sequence of native gates.
08 / 22
§ compilation

Problem → algorithm → circuit → optimized.

GROVER · n = 2 QUBITS
09 / 22
§ transpilation

Same circuit, three native gate sets.

The hardware person hands you a set. You compile onto it. Every compile is a trade between depth, count, and two-qubit gates.
TRANSPILED GROVER CIRCUIT
10 / 22
PART II · HARDWARE-DOWN

Starting from the
qubit.

A single journey, eight stages, from "is there a chip here" to "here is your native gate."
11 / 22
§ the pipeline

Eight stages. One chip. One calibration.

We'll visit every stop in turn. Each one answers a single question, and hands its answer forward to the next.
1 find resonator ω_r, κ 2 find qubit ω_q (rough) 3 sharpen ω_q chevron 4 calibrate π/2 Rabi → Ω 5 fine-tune ω_q Ramsey 6 readout χ, SNR 7 energy lifetime T₁ 8 phase coherence T₂* Eight measurements. One native gate. { √X, Rz } — with Ω, χ, T₁, T₂* all pinned
12 / 23
§ stage 1 · find the resonator

First, find the resonator.

Before anything else: sweep a probe tone, watch for a dip in transmission. That's the readout resonator. Nothing else on the chip is findable until this is pinned down.
SINGLE-TONE SPECTROSCOPY
WHAT WE LEARN
ωr ≈ 7 GHz
κ = linewidth
The qubit is hiding somewhere nearby — dispersively shifting this dip — but we can't see it yet.
12 / 22
§ stage 2 · find the qubit

Two tones: use the resonator to find the qubit.

Park the probe at ωr. Sweep a second drive tone. When it hits ωq, the qubit flips — and the dispersive shift moves the resonator. The readout signal jumps.
TWO-TONE SPECTROSCOPY
WHAT WE LEARN
ωq ≈ 5 GHz
Rough estimate — good to ~MHz. We'll sharpen it with Rabi and Ramsey.
13 / 22
§ stage 3 · sharpen ω_q

The Rabi chevron sharpens the qubit frequency.

Sweep drive frequency and duration. Off-resonance: faster, weaker. On-resonance: slowest, full contrast. The spine of the chevron is ωq.
FORMULA
Ωeff = √(Ω² + Δ²)
P₁ = Ω²⁄Ω²+Δ² · sin²(Ωeff t / 2)
Bright spine = on resonance.
14 / 22
§ stage 4 · calibrate π/2

Now calibrate the gate. Find π/2.

On the spine (Δ = 0), population oscillates as sin²(Ωt/2). Drag the marker to the first half-maximum. That duration is your π/2 gate.
RABI OSCILLATION · DRAG
BLOCH
READOUT
15 / 22
§ stage 5 · fine-tune ω_q

Ramsey fine-tunes the qubit frequency.

π/2 · wait τ · π/2. If the drive is detuned by Δ, fringes oscillate at Δ. Slide Δ → 0 and the fringes flatten. That's how we pin ωq to the kHz.
P(|1⟩) vs τ
DETUNING Δ
16 / 22
§ stage 6 · readout

One resonator, two dips — two clouds in IQ.

The qubit shifts the resonator by ±χ. Probe in between — each shot lands in one of two clouds on the IQ plane.
RESONATOR DIP · |0⟩ vs |1⟩
IQ PLANE · SINGLE-SHOT
ground cloud · |0⟩
Cloud separation / cloud width = readout SNR. Overlap = assignment error.
17 / 22
§ stage 7 · energy lifetime

T₁ · how long the qubit holds |1⟩.

Prepare |1⟩ · wait t · measure. P(|1⟩) = e−t/T₁. Slide to see how decay looks at different T₁.
DECAY CURVE
T₁
T₁ budgets everything: the longer the circuit, the more decoherence it eats.
18 / 22
§ stage 8 · phase coherence

T₂* · how long the phase stays coherent.

Ramsey's envelope. Slow noise → Gaussian decay. T₂* ≤ 2T₁, always. Usually much shorter.
RAMSEY WITH FIXED Δ = 5 MHz
T₂*
19 / 22
§ bonus · compose

Every single-qubit gate, built from √X and virtual Rz.

Only one physical 1-qubit gate is calibrated: √X = Rx(π/2). Rz is a software phase. Everything else composes from those.
target:
SEQUENCE (left → right applied to |0⟩)
RESULTING UNITARY
20 / 22
§ the loop closes

Every number you measured is a number the compiler needs.

WHAT THE PHYSICS SIDE MEASURED
ωr · resonator spectroscopy
ωq · two-tone + chevron + Ramsey
Ω, tπ/2 · Rabi
T₁ · inversion recovery
T₂* · Ramsey envelope
χ, κ, Fro · IQ clouds
⇄
WHAT THE ALGORITHM SIDE NEEDS
gate list · { Rx(π/2), Rz(θ), CZ }
gate timing · tπ/2 ≈ 20 ns, CZ ≈ 100 ns
1-q fidelity · 1 − F ∝ tgate / T₂*
2-q fidelity · from randomized benchmarking
readout error · IQ cloud overlap
connectivity · coupling graph
Same table of numbers. Two people reading it from opposite ends.
21 / 22
§ recap

Two tracks. One bridge.

PHYSICS GAVE US
resonator · qubit freq · π/2 · readout · T₁ · T₂*
THE BRIDGE IS
a native gate set with durations, fidelities, and readout error — handed both ways
INFO THEORY USES
that set to transpile and optimize — returns a pulse schedule
Questions?
22 / 22