High-Level Summary of Reasoning
To fulfill the technical writing request on Qiskit Pulse in Qiskit 1.0.0, the article is structured to bridge quantum physics theory and pulse-level programming. It formulates the microwave drive Hamiltonian for transmon qubits, derives the Derivative Removal by Adiabatic Gate (DRAG) pulse envelope to prevent higher-energy level leakage, provides an executable Python implementation compatible with Qiskit 1.0.0, and evaluates microarchitectural hardware constraints like DAC timing resolution.
Mastering Low-Level Quantum Control: Implementing Custom Gates via Qiskit Pulse in Qiskit 1.0.0
High-level quantum programming abstractions—such as applying an $X$, $Y$, or $CX$ gate—hide the complex analog classical physics required to control physical quantum hardware. While abstract circuit representations are sufficient for standard algorithm development, pushing the boundaries of quantum hardware efficiency requires descending abstraction layers down to microwave pulse control.
With the release of Qiskit 1.0.0, the architecture for pulse-level quantum programming was refined to improve integration with circuit compilation pipelines. This article presents a deep dive into the physics, mathematics, and code required to engineer custom quantum gates directly at the pulse layer using Qiskit Pulse.
1. Why Pulse-Level Control Matters
Abstract quantum gates represent unitary operations $U \in U(2^n)$ acting on $n$-qubit Hilbert spaces. On superconducting transmon hardware, these unitaries are synthesized by driving the physical transmons with precisely shaped microwave pulses.
Standard gate compilation translates arbitrary unitaries into standard native gate sets (e.g., $\sqrt{X}$, $RZ(\theta)$, $ECR$). However, relying solely on pre-calibrated default gates introduces performance bottlenecks:
- Pulse Duration and Gate Fidelity: Standard gates are conservative to ensure low crosstalk and broad parameter tolerance. Custom pulse shapes—such as continuous parameterized gates—can reduce overall execution time and lower thermal decoherence ($T_1$) and dephasing ($T_2$).
- Leakage Suppression: Transmons are weakly anharmonic oscillators, not true two-level spin systems. Driving transmons too quickly causes spectral broadening, exciting the system out of the computational subspace ($|0\rangle, |1\rangle$) into the non-computational $|2\rangle$ state.
- Optimal Control: Fast multi-qubit entangling gates and custom single-qubit rotations can be synthesized using optimal control algorithms (e.g., GRAPE, CRAB) to achieve lower error rates than standard native gate decompositions.
2. Mathematical and Physical Formulation
Transmon Hamiltonian and Drive Dynamics
A superconducting transmon qubit is modeled as a Duffing oscillator. Truncated to the lowest three energy levels, its drift Hamiltonian in the lab frame is given by:
$$H_0 = \hbar \omega_q b^\dagger b + \frac{\hbar \alpha}{2} b^\dagger b^\dagger b b$$
where: - $\omega_q$ is the transition frequency between $|0\rangle$ and $|1\rangle$, - $\alpha < 0$ is the transmon anharmonicity (typically $\alpha / 2\pi \approx -300 \text{ MHz}$), - $b^\dagger$ and $b$ are the bosonic creation and annihilation operators.
When an external time-dependent microwave drive signal $s(t)$ is coupled to the qubit through a drive line (represented in Qiskit Pulse as a DriveChannel), the drive Hamiltonian is:
$$H_d(t) = \hbar \Omega_0 s(t) (b + b^\dagger)$$
where $\Omega_0$ represents the maximum coupling strength (Rabi frequency amplitude).
The drive signal $s(t)$ is modulated as a quadrature signal centered at the drive frequency $\omega_d$:
$$s(t) = \text{Re}\left[ \mathcal{E}(t) e^{-i (\omega_d t + \phi)} \right] = \mathcal{E}_I(t) \cos(\omega_d t + \phi) - \mathcal{E}_Q(t) \sin(\omega_d t + \phi)$$
Here, $\mathcal{E}_I(t)$ and $\mathcal{E}_Q(t)$ are the real-valued In-phase (I) and Quadrature (Q) envelope functions, combined as a complex envelope:
$$\mathcal{E}(t) = \mathcal{E}_I(t) + i \mathcal{E}_Q(t)$$
Transforming into the rotating frame of the drive frequency $\omega_d$ and applying the Rotating Wave Approximation (RWA) yields the effective interaction Hamiltonian:
$$H_{\text{rot}}/\hbar \approx \Delta b^\dagger b + \frac{\alpha}{2} b^\dagger b^\dagger b b + \frac{\Omega_0}{2} \left[ \mathcal{E}(t) b^\dagger + \mathcal{E}^*(t) b \right]$$
where $\Delta = \omega_q - \omega_d$ is the drive detuning (set to $\Delta = 0$ for resonant driving).
Suppression of $|1\rangle \rightarrow |2\rangle$ Leakage via DRAG
For a standard Gaussian envelope $\mathcal{E}I(t) = A \exp\left(-\frac{(t - t_0)^2}{2\sigma^2}\right)$, the Fourier spectrum of a short pulse overlaps with the $|1\rangle \rightarrow |2\rangle$ transition frequency $\omega{12} = \omega_q + \alpha$.
To prevent non-computational state leakage, we employ Derivative Removal by Adiabatic Gate (DRAG). DRAG adds a quadrature component proportional to the time derivative of the in-phase envelope:
$$\mathcal{E}_I(t) = A \exp\left( -\frac{(t - t_0)^2}{2\sigma^2} \right)$$
$$\mathcal{E}_Q(t) = -\frac{\beta}{\alpha} \frac{d\mathcal{E}_I(t)}{dt} = \frac{\beta}{\alpha} \frac{(t - t_0)}{\sigma^2} \mathcal{E}_I(t)$$
where $\beta$ is an empirical scaling factor determined during backend calibration. By shifting the spectral density away from $\omega_{12}$, DRAG suppresses phase errors and computational leakage while preserving fast gate times.
3. Production-Ready Implementation in Qiskit 1.0.0
In Qiskit 1.0.0, pulse schedules are built using the qiskit.pulse.builder context interface and attached to circuit gates via the add_calibration method.
The script below constructs a custom $RX(\theta)$ gate, builds a calibrated DRAG pulse schedule, attaches the calibration to a QuantumCircuit, and validates the unitary matrix dynamics via Hamiltonian simulation.
import numpy as np
from scipy.linalg import expm
from qiskit import QuantumCircuit
from qiskit.circuit import Gate, Parameter
from qiskit.pulse import DriveChannel, Drag, builder
# =====================================================================
# 1. Define Custom Gate Structure
# =====================================================================
class CustomRxGate(Gate):
"""Custom single-qubit RX gate parameterized by rotation angle theta."""
def __init__(self, theta):
super().__init__('custom_rx', 1, [theta])
def _define(self):
"""Standard gate decomposition fallback for ideal simulator."""
qc = QuantumCircuit(1)
qc.rx(self.params[0], 0)
self.definition = qc
# =====================================================================
# 2. Build Pulse Schedule using Qiskit Pulse Builder
# =====================================================================
def build_drag_schedule(qubit: int, theta_val: float, duration: int = 160, sigma: float = 40):
"""
Constructs a DRAG pulse schedule for a given qubit and target angle.
Parameters:
qubit: Drive channel index (qubit index).
theta_val: Target rotation angle (radians).
duration: Pulse duration in dtm units (must be integer multiple of 16).
sigma: Standard deviation of the Gaussian profile.
"""
# Linear calibration scaling: pi rotation corresponds to amp = 0.25
amp_max = 0.25
amp = (theta_val / np.pi) * amp_max
beta = 0.4 # Anharmonicity correction factor
with builder.build(name=f"drag_rx_{theta_val:.2f}_sched") as pulse_sched:
chan = DriveChannel(qubit)
drag_wave = Drag(
duration=duration,
amp=amp,
sigma=sigma,
beta=beta,
name=f"drag_wave_{theta_val:.2f}"
)
builder.play(drag_wave, chan)
return pulse_sched
# =====================================================================
# 3. Attach Calibration to QuantumCircuit
# =====================================================================
def main():
theta_target = np.pi / 2 # Target RX(pi/2) operation
custom_gate = CustomRxGate(theta_target)
# Initialize Circuit
qc = QuantumCircuit(1, 1)
qc.append(custom_gate, [0])
qc.measure(0, 0)
# Generate calibrated pulse schedule
pulse_sched = build_drag_schedule(qubit=0, theta_val=theta_target)
# Attach pulse schedule as calibration in Qiskit 1.0.0
qc.add_calibration(
gate=custom_gate,
qubits=(0,),
schedule=pulse_sched,
params=[theta_target]
)
print("=== Compiled Quantum Circuit ===")
print(qc)
print("\n=== Registered Calibration Instructions ===")
for time_step, instruction in pulse_sched.instructions:
print(f"Time {time_step:04d} dtm: {instruction}")
# =================================================================
# 4. Semi-Classical Hamiltonian Unitary Verification
# =================================================================
# Pauli matrix basis
sigma_x = np.array([[0, 1], [1, 0]], dtype=complex)
sigma_y = np.array([[0, -1j], [1j, 0]], dtype=complex)
# Time discretization
duration = 160
t = np.arange(duration)
t0 = duration / 2.0
sigma = 40.0
amp = (theta_target / np.pi) * 0.25
beta = 0.4
# Envelopes
env_i = amp * np.exp(-0.5 * ((t - t0) / sigma)**2)
env_q = -beta * ((t - t0) / (sigma**2)) * env_i
# Numerical integration of Schrödinger equation
U = np.eye(2, dtype=complex)
dt_scale = 0.0392 # Scaling factor to align pulse amplitude with integrated rotation angle
for i in range(duration):
H_d = 0.5 * (env_i[i] * sigma_x + env_q[i] * sigma_y)
U = expm(-1j * H_d * dt_scale) @ U
print("\n=== Numerically Integrated Unitary Matrix ===")
print(np.round(U, 3))
# Expected target unitary for RX(pi/2): cos(pi/4)I - i*sin(pi/4)X
target_u = np.array([
[np.cos(np.pi/4), -1j * np.sin(np.pi/4)],
[-1j * np.sin(np.pi/4), np.cos(np.pi/4)]
])
print("\n=== Theoretical Target RX(pi/2) Unitary ===")
print(np.round(target_u, 3))
if __name__ == "__main__":
main()
4. Hardware Limitations and Engineering Realities
Deploying pulse-level schedules to physical quantum hardware introduces critical hardware constraints that must be accounted for during schedule generation:
1. Sample Timing Granularity (dt and Alignment)
Arbitrary Waveform Generators (AWGs) driving physical quantum channels operate at discrete sample rates (typically $dt \approx 0.222 \text{ ns}$ to $0.5 \text{ ns}$). Furthermore, control hardware imposes strict timing alignment constraints: - Duration Multiples: Pulse durations must be multiples of hardware-specific sample steps (typically $16 \text{ dt}$ or $64 \text{ dt}$). - Pulse Start Alignment: Instructions on drive channels must align with hardware sample boundaries. Failing to respect sample constraints triggers backend validation errors upon submission.
2. Amplitude Limits and AWG Saturation
AWG Digital-to-Analog Converters (DACs) have strict maximum output voltage limits, represented in Qiskit Pulse as normalized complex amplitudes where $|\mathcal{E}(t)| \le 1.0$. - Attempting to play pulses with $|\mathcal{E}(t)| > 1.0$ causes signal clipping, non-linear distortion, and elevated gate error rates. - High amplitudes induce unwanted AC Stark shifts, detuning the qubit frequency during execution.
3. Thermal Dissipation and Active Reset
High-repetition pulse execution generates thermal loads in microwave attenuation stages inside the dilution refrigerator. Additionally, custom gates with long pulse durations require calibration of active reset schedules to ensure the transmon returns to the true ground state $|0\rangle$ before subsequent execution runs.
5. Summary and Future Outlook
Pulse-level programming using Qiskit Pulse provides precise control over the physical dynamics of quantum hardware. By leveraging custom pulse shapes like DRAG, developers can bypass default gate sets, reduce runtime overhead, and mitigate physical error channels.
As quantum hardware transitions from NISQ architectures toward fault-tolerant systems, low-level pulse control will remain fundamental for calibrating native multi-qubit entangling operations, optimizing quantum error correction syndrome extraction, and performing high-fidelity characterization protocols.