quchip.analysis.dispersive_readout

Closed-form dispersive-readout analysis — pointer states, SNR, assignment error.

Maps the dispersive parameters of a qubit–resonator pair — the dispersive pull chi and resonator linewidth kappa — plus a readout drive and an integration time to steady-state figures of merit, with no solver run and no resonator in the Hilbert space. Composes with quchip.chip.transformations.eliminate(), which reports chi/kappa per surviving qubit:

res = eliminate(chip, "readout_res")
ro = analyze_dispersive_readout(
    chi=res.effective_params["q0"]["chi"],
    kappa=res.effective_params["q0"]["kappa"],
    tau=500.0, n_photons=2.0,
)
ro.snr, ro.assignment_error

Physics (driven, damped linear resonator, steady state of d⟨a⟩/dt = −(iδ + κ/2)⟨a⟩ − iε):

delta_r ≡ f_r|0 − f_drive drive placement [GHz] (Δ_r = ω_r − ω_d) δ_j = 2π·(delta_r + chi_eff·j) resonator−drive detuning, qubit in |j⟩ [rad/ns] α_j = −i·ε / (κ/2 + i·δ_j) coherent pointer state n̄_j = |α_j|² steady-state photons (emergent) σ = 1/√(2κτ) integrated vacuum-noise blob width SNR = |α₁ − α₀|·√(2κτ) p_err = ½·erfc(SNR/(2√2)) two equal Gaussians, optimal discriminant Γ_m = κ·|α₁ − α₀|²/2 measurement-induced dephasing [1/ns]

χ convention: chi is the full pull χ_pull ≡ f_r(qubit |1⟩) − f_r(qubit |0⟩) in GHz — 2× the σ_z-convention χ of H_disp = (ω_r + χσ_z)a†a. In the small-χ limit Γ_m → 8·χ_σz²·n̄/κ with χ_σz = π·chi in rad/ns.

Unit convention: public inputs chi and delta_r are GHz (ordinary frequency), kappa is a rate in 1/ns, tau is in ns, eps is in rad/ns. The GHz→rad/ns conversions (2π) happen exactly once, at the public boundary of analyze_dispersive_readout() — local physics conversions of an analysis module, distinct from the engine’s own Hamiltonian-assembly 2π boundary in stage 2.

Everything is closed-form algebra in the array namespace of its inputs, so the result is JAX-traceable and differentiable end-to-end: jax.grad of result.snr with respect to any chip parameter works when chi/kappa come from a traced eliminate().

Approximations (declared explicitly): steady state only (no ring-up transient), linear resonator, 2nd-order dispersive coupling, no measurement-induced qubit T1. The optional strong-drive correction chi_eff = chi/(1 + n̄₀/n_crit) is applied only when n_crit is given.

References

Koch et al., Charge-insensitive qubit design derived from the Cooper pair box, PRA 76, 042319 (2007), §IV — dispersive χ for the transmon. Gambetta et al., Qubit-photon interactions in a cavity: Measurement-induced dephasing and number splitting, PRA 74, 042318 (2006) — Γ_m. Krantz et al., A quantum engineer’s guide to superconducting qubits, Appl. Phys. Rev. 6, 021318 (2019), §V — dispersive readout, SNR, p_err. Blais et al., Circuit quantum electrodynamics, RMP 93, 025005 (2021) — general cQED readout theory, n_crit.

Functions

analyze_dispersive_readout(chi, kappa, tau, *)

Compute closed-form steady-state readout figures of merit from (chi, kappa).

Classes

DispersiveReadoutResult(pointer_states, ...)

Store steady-state dispersive-readout figures of merit.

class quchip.analysis.dispersive_readout.DispersiveReadoutResult(pointer_states, photon_numbers, sigma, snr, assignment_error, dephasing_rate, chi_eff, validity, notes)

Bases: object

Store steady-state dispersive-readout figures of merit.

All numeric fields stay in the array namespace of the inputs (JAX in, JAX out), so the whole result traces under jax.jit/grad. validity holds {"n_over_ncrit", "below_ncrit"} when n_crit was given — below_ncrit is then a traced boolean under jit/grad; read it outside the traced region or branch with jnp.where — and is empty otherwise. chi here is χ_pull (f_r|1 − f_r|0, 2× the σ_z-convention χ).

Parameters:

• pointer_states (Any)

• photon_numbers (Any)

• sigma (Any)

• snr (Any)

• assignment_error (Any)

• dephasing_rate (Any)

• chi_eff (Any)

• validity (dict[str, Any])

• notes (list[str])

pointer_states

Complex α_j in the IQ plane, shape (levels,).

Type:

Any

photon_numbers

Steady-state photons |α_j|², shape (levels,).

Type:

Any

sigma

Integrated vacuum-noise blob width 1/√(2κτ) (dimensionless, α-plane units).

Type:

Any

snr

|α₁ − α₀|·√(2κτ).

Type:

Any

assignment_error

½·erfc(SNR/(2√2)) — optimal linear discriminant between two equal Gaussians.

Type:

Any

dephasing_rate

Measurement-induced dephasing Γ_m = κ·|α₁ − α₀|²/2 in 1/ns.

Type:

Any

chi_eff

chi, or chi/(1 + n̄₀/n_crit) when n_crit was given (GHz).

Type:

Any

validity

See above.

Type:

dict[str, Any]

notes

Explicitly dropped physics.

Type:

list[str]

pointer_states: Any

photon_numbers: Any

sigma: Any

snr: Any

assignment_error: Any

dephasing_rate: Any

chi_eff: Any

validity: dict[str, Any]

notes: list[str]

summary()

Print and return a formatted summary.

Concrete values only — call it outside jax.jit/grad regions.

Return type:

str

quchip.analysis.dispersive_readout.analyze_dispersive_readout(chi, kappa, tau, *, n_photons=None, eps=None, delta_r=0.0, n_crit=None, levels=2)

Compute closed-form steady-state readout figures of merit from (chi, kappa).

Parameters:

• chi (Any) – Dispersive pull χ_pull = f_r(qubit |1⟩) − f_r(qubit |0⟩) in GHz — 2× the σ_z-convention χ. Take it from eliminate(...).effective_params[qubit]["chi"].

• kappa (Any) – Resonator linewidth (rate) in 1/ns, e.g. effective_params[...]["kappa"].

• tau (Any) – Integration time in ns.

• n_photons (Any) – Target steady-state photon number with the qubit in |0⟩. Exactly one of n_photons and eps must be given; the drive rate is then ε = √(n̄₀·((κ/2)² + δ₀²)).

• eps (Any) – Readout drive rate in rad/ns (power-user path; exactly one of n_photons and eps).

• delta_r (Any) – Detuning of the qubit-in-ground resonator from the drive, delta_r = f_r|0 − f_drive in GHz — the literature’s Δ_r = ω_r − ω_d. 0.0 drives on the qubit-in-ground resonance; positive values place the drive below f_r|0.

• n_crit (Any) – Critical photon number Δ²/(4g²). When given, the strong-drive collapse chi_eff = chi/(1 + n̄₀/n_crit) is applied and validity reports n_over_ncrit/below_ncrit.

• levels (int) – Number of qubit levels to compute pointer states for (static Python int — it fixes array shapes; 3 includes |f⟩). The pull of level j is the linear-dispersive chi·j.

Return type:

DispersiveReadoutResult

Raises:

ValueError – If both or neither of n_photons and eps are given (a static argument-presence check — never a traced-value comparison).

Examples

>>> from quchip import analyze_dispersive_readout
>>> ro = analyze_dispersive_readout(chi=0.002, kappa=0.005, tau=500.0, n_photons=2.0)
>>> snr, p_err = ro.snr, ro.assignment_error

chi and kappa are typically taken from eliminate(chip, "readout_res").effective_params[qubit].