quchip.devices.transmon.charge_basis

Charge-basis transmon — circuit-level transmon in the integer charge basis.

Hamiltonian (native basis, Koch et al. 2007):

\[H = 4 E_C (\hat n - n_g)^2 - E_J \cos\hat\varphi\]

where \(\hat n\) is diagonal on the integer charge basis \(\{|{-n_\mathrm{cut}}\rangle, \ldots, |n_\mathrm{cut}\rangle\}\) and \(\cos\hat\varphi = \tfrac{1}{2}(|n\rangle\langle n+1| + \mathrm{h.c.})\).

Unlike DuffingTransmon, the spectrum is computed by exact diagonalization of the truncated charge basis — no Duffing expansion. Charge-dispersion with \(n_g\) is captured exactly, which the Duffing expansion misses outside the deep transmon regime \(E_J/E_C \gtrsim 50\).

References

  • Koch, Yu, Gambetta, Houck, Schuster, Majer, Blais, Devoret, Girvin & Schoelkopf, Charge-insensitive qubit design derived from the Cooper pair box, PRA 76, 042319 (2007), §II.A–§II.C.

  • Krantz et al., A quantum engineer’s guide to superconducting qubits, APR 6, 021318 (2019), §III.

Example

>>> from quchip.devices.transmon import ChargeBasisTransmon
>>> q = ChargeBasisTransmon(E_C=0.25, E_J=20.0, levels=3)

Classes

ChargeBasisTransmon(E_C, E_J[, n_g, levels, ...])

Transmon in the integer charge basis — exact diagonalization.
class quchip.devices.transmon.charge_basis.ChargeBasisTransmon(E_C, E_J, n_g=0.0, levels=3, label=None, *, num_basis=61, collapse_model='fermi_golden', coupling_channel=None, collapse_rate_threshold=1e-08, **noise_kwargs)[source]

Bases: CircuitDevice

Transmon in the integer charge basis — exact diagonalization.

Parameters:

  • E_C (float) – Charging energy in GHz. Must be positive. May be a JAX tracer.

  • E_J (float) – Josephson energy in GHz. Must be positive. May be a JAX tracer.

  • n_g (float, default 0.0) – Offset charge (units of \(2e\)). May be a JAX tracer.

  • levels (int, default 3) – Truncated eigenbasis size.

  • label (str or None) – Auto-generated as charge_basis_transmon_{n} if omitted.

  • num_basis (int, default 61) – Charge-basis cutoff — must be odd, corresponding to \(n \in [-n_\mathrm{cut}, +n_\mathrm{cut}]\) with \(n_\mathrm{cut} = (\text{num\_basis} - 1)/2\).

  • collapse_model ("fermi_golden" or "ladder", default "fermi_golden") – See CircuitDevice.

  • collapse_rate_threshold (float, default 1e-8) – See CircuitDevice.

  • **noise_kwargs – Forwarded to BaseDevice (T1, T2, thermal_population).

  • coupling_channel (Literal['charge', 'flux'] | None)

Notes

The T1 collapse-operator normalization assumes T1 is set by charge-operator-coupled relaxation (Breuer & Petruccione §3.4). For phonon / quasiparticle / flux-dominated T1, override collapse_operators() or pass collapse_model='ladder'.

tunable_param_names = ('E_C', 'E_J', 'n_g')

Bare parameters this device exposes as differentiable / tunable scalars. fit_a_dress walks this tuple to discover what it is allowed to optimize on each device, decoupling the inverse-design surface from any specific device model. Three states, keyed on whether the value is explicitly declared:

  • No explicit declaration anywhere in the DeviceModel lineage — the default is derived: every declared parameter() field, in declaration order (see DeviceModel.__init_subclass__).

  • Explicit tuple on the class or an ancestor — exact curation, validated at class-definition time; authoritative and inherited until a subclass explicitly replaces it.

  • Explicit empty tuple — deliberately freezes the device (and its subclasses, until one replaces it) out of inverse design.

On a plain (non-DeviceModel) BaseDevice subclass there is no derivation; the default stays empty unless the subclass declares its own tuple — e.g. Fluxonium uses ("E_C", "E_J", "E_L", "phi_ext").

approximation = 'Exact diagonalization in the truncated integer charge basis; accuracy governed by num_basis.'

Declared approximation-regime statement surfaced by physics_notes(), mirroring approximation — this class does not inherit from DeviceModel, so the attribute and its surfacing are declared here directly.

tunable_param_bounds(name, value)[source]

n_g lives in [-0.5, 0.5] (one charge period); other params delegate.

Parameters:
Return type:

tuple[float, float]

physics_notes()[source]

Return declared integer-charge-basis assumptions.

Return type:

list[str]

classmethod from_frequency(freq, anharmonicity, n_g=0.0, levels=3, label=None, *, num_basis=61, collapse_model='fermi_golden', coupling_channel=None, collapse_rate_threshold=1e-08, **noise_kwargs)[source]

Construct from (freq, anharmonicity) using the Koch-regime inversion.

Uses \(E_C = -\alpha\) and \(E_J = (\omega + E_C)^2 / (8 E_C)\). Residual between the Duffing approximation and the exact diagonalized spectrum is typically <1% for \(E_J/E_C > 50\), growing below that. A concrete-scalar warning fires at \(E_J/E_C < 20\).

Parameters:

  • freq (float)

  • anharmonicity (float)

  • n_g (float)

  • levels (int)

  • label (str | None)

  • num_basis (int)

  • collapse_model (Literal['fermi_golden', 'ladder'])

  • coupling_channel (Literal['charge', 'flux'] | None)

  • collapse_rate_threshold (float)

  • noise_kwargs (float | None)

Return type:

ChargeBasisTransmon

property computational: bool

Charge-basis transmon is a computational qubit.

to_dict()[source]

Extend CircuitDevice.to_dict() with the charge-basis circuit parameters.

Return type:

dict[str, Any]

classmethod from_dict(d)[source]

Reconstruct from to_dict() output.

On the registry root, dispatch to the concrete subclass named by data["type"] (forwarding *args / **kwargs). On a concrete subclass, defer to _from_dict_payload(). Concrete subclasses that carry payload override this method directly.

Parameters:

d (dict[str, Any])

Return type:

ChargeBasisTransmon