---
title: 'Bosonic Qiskit: A Hybrid Quantum Toolkit'
url: https://www.emergentmind.com/topics/bosonic-qiskit
type: topic
---

# Bosonic Qiskit: A Hybrid Quantum Toolkit

Bosonic Qiskit denotes a Qiskit-based software framework for programming and simulating hybrid quantum systems containing both discrete-variable qubits and bosonic modes, and, in a broader literature usage, can also denote Qiskit-like abstractions for bosonic registers, bosonic codes, and hybrid qubit–boson compilation layers [2209.11153]. In its original software sense, it is an extension to the standard Qiskit SDK that introduces an instruction set architecture (ISA) and abstract machine model (AMM) for qubit–qumode systems, together with a concrete gate set, measurement interface, and analysis tools for continuous-variable and hybrid dynamics [2209.11153]. Subsequent work places this framework within a larger ecosystem that includes bosonic encodings in circuit QED, gate-level programming for resonator–qubit processors, symbolic Hamiltonian compilation, and qubit-based emulation of bosonic systems [2008.13471], [2506.00215].

## 1. Definition, scope, and terminology

Bosonic Qiskit was introduced as “an extension to the standard Qiskit SDK that lets you program and simulate hybrid quantum systems containing both discrete qubits and bosonic modes (qumodes) in a unified way” [2209.11153]. Its stated goal is to develop an ISA for hybrid qubit/bosonic mode systems and an AMM that contains “a description of the appropriate error models associated with the gates, measurements and time evolution of the hardware” [2209.11153]. The software is implemented as an extension of Qiskit and is intended for “simulating new hybrid systems, verifying proposed physical systems, and modeling systems larger than can currently be constructed” [2209.11153].

Within the literature, the phrase “Bosonic Qiskit” is not entirely univocal. In the original C2QA software paper it names a specific Qiskit extension for hybrid qubit–qumode circuits [2209.11153]. In later compiler work it appears as a gate-level interface for qubit–boson hardware that “enables the assembly of qubit-boson gates but does not directly apply compilation rules to second quantized Hamiltonians” [2506.00215]. In reviews of bosonic encodings in circuit QED, the phrase is also used more generically to describe a software abstraction in which a cavity is represented as a truncated bosonic register, with logical bosonic codes treated as subspaces of that oscillator Hilbert space [2008.13471]. A distinct usage appears in work on hard-core boson circuit simulation, where “bosonic Qiskit” means a Qiskit-like backend that represents ordinary qubit circuits through hard-core boson creation and annihilation operators rather than through matrices on bit strings [2606.28004].

This terminological plurality matters because it separates at least three layers. First, there is a concrete SDK extension centered on `QumodeRegister` and `CVCircuit` [2209.11153]. Second, there is a broader architectural notion of a Qiskit-like environment whose primitive register is bosonic rather than purely qubit-based [2008.13471]. Third, there are higher-level compiler and simulation backends that either sit above Bosonic Qiskit or reinterpret its role in more specialized settings [2506.00215], [2606.28004]. A plausible implication is that “Bosonic Qiskit” functions less as a single fixed formalism than as a software stratum in which bosonic modes are elevated to first-class computational objects.

## 2. Architectural model and bosonic representation

The core Hilbert-space model is explicitly hybrid:
\[
\mathcal{H} = \mathcal{H}_{\rm qubit}^{\otimes m}\otimes \mathcal{H}_{\rm qumode}^{\otimes n}.
\]
The qubit gate set remains standard Qiskit, while Bosonic Qiskit adds qumode gates and hybrid qubit–qumode gates drawn from the ISA of Girvin et al. [2209.11153]. A bosonic mode, or qumode, is treated as a quantized harmonic oscillator with Fock basis \(\{|n\rangle\}_{n=0}^\infty\), ladder operators \(a,a^\dagger\), and number operator \(\hat n=a^\dagger a\) [2209.11153].

Computationally, each mode is represented in a truncated Fock basis. The software uses only the lowest \(d=2^k\) Fock levels, where \(k\) is a user-chosen number of qubits per mode. A typical register instantiation is
```python
qmr = c2qa.QumodeRegister(num_qumodes=1, num_qubits_per_qumode=6)
```
which produces a single qumode with cutoff \(d=64\) [2209.11153]. Internally, each mode is encoded as a block of \(k\) Qiskit qubits in binary, but the programming model presents modes rather than the underlying encoding qubits [2209.11153].

In the truncated basis, the annihilation and creation operators become finite-dimensional matrices. For a four-level truncation,
\[
a= \begin{pmatrix}
0 & 1 & 0 & 0\\
0 & 0 & \sqrt{2} & 0\\
0 & 0 & 0 & \sqrt{3}\\
0 & 0 & 0 & 0
\end{pmatrix},\qquad
a^{\dagger}= \begin{pmatrix}
0 & 0 & 0 & 0\\
1 & 0 & 0 & 0\\
0 & \sqrt{2} & 0 & 0\\
0 & 0 & \sqrt{3} & 0
\end{pmatrix}.
\]
Because of truncation, the canonical commutation relation is violated at the top level; for example,
\[
a a^{\dagger}\ket{3} = 0,\qquad
(a^{\dagger} a + 1 ) \ket{3} = 4.
\]
The software documentation therefore emphasizes choosing cutoffs high enough that dynamics rarely occupy the top Fock level, normal-ordering operators where appropriate, and handling large displacements and squeezing with care [2209.11153].

At the circuit-object level, Bosonic Qiskit introduces `QumodeRegister` and `CVCircuit`. The latter subclasses Qiskit’s `QuantumCircuit`, accepts `QumodeRegister`, `QuantumRegister`, and `ClassicalRegister` instances in a unified constructor, and adds methods for bosonic gates, Wigner-function analysis, and generalized measurements [2209.11153]. This design preserves compatibility with the ordinary Qiskit circuit model while extending it to continuous-variable objects.

## 3. Gate set, measurements, and analysis tools

The implemented gate inventory consists of Gaussian single- and two-mode gates, hybrid qubit–boson gates, and specialized number-selective operations. The following table organizes the gates explicitly enumerated in the software paper.

| Gate class | Operator | Bosonic Qiskit name |
|---|---|---|
| Phase rotation | \(e^{i\theta \hat{n}}\) | `cv_r` |
| Displacement | \(e^{\theta a^{\dagger} - \theta^* a}\) | `cv_d` |
| Single-mode squeezing | \(e^{\frac{1}{2}(\theta^* a a - \theta a^{\dagger}a^{\dagger})}\) | `cv_sq` |
| Two-mode squeezing | \(e^{(\theta^* a b - \theta a^\dagger b^\dagger)}\) | `cv_sq2` |
| Beamsplitter | \(e^{\theta a^{\dagger}b-\theta^* b^{\dagger}a}\) | `cv_bs` |
| Controlled rotation | \(e^{\sigma^z \otimes i \theta \hat{n}}\) | `cv_c_r` |
| Controlled displacement | \(e^{\sigma^z\otimes (\theta a^{\dagger} - \theta^* a)}\) | `cv_c_d` |
| Controlled beamsplitter | \(e^{\sigma^z\otimes ( \theta a^{\dagger}b-\theta^*b^{\dagger}a)}\) | `cv_c_bs` |
| SNAP | \(e^{\sigma^z  \otimes i \theta_n \ket{n}\bra{n}}\) | `cv_snap` |
| Exponential SWAP | \(e^{i \frac{\theta}{2} \mathrm{SWAP}}\) | `cv_eswap` |

These gates are implemented as unitary matrices acting on the qubits encoding the target qumodes and, when relevant, control qubits, then wrapped as Qiskit `UnitaryGate` objects [2209.11153]. The gate inventory aligns closely with the cQED primitives emphasized in reviews of bosonic qubits, where displacement, SNAP, parity control, and dispersive interactions are the basic workhorses for bosonic control and quantum error correction [2008.13471].

Measurement support is likewise hybrid. Standard qubit measurements use the ordinary computational basis interface, while bosonic modes are measured in the Fock basis through `cv_measure` [2209.11153]. The Fock number of a mode is encoded in binary across the classical bits assigned to that mode, and helper functions such as `cv_fockcounts` convert returned bit strings into decimal occupation numbers [2209.11153]. The paper explicitly notes that continuous POVMs such as homodyne or heterodyne are not implemented as direct measurement primitives; quadrature information instead enters through Wigner-function calculations and related post-processing [2209.11153].

A distinctive feature of Bosonic Qiskit is its built-in phase-space analysis layer. It provides utilities to compute and plot Wigner functions, to animate Wigner evolution under a circuit, to perform reduced density-matrix extraction through partial tracing, and to perform maximum-likelihood estimation of Wigner functions from ensembles of trajectories [2209.11153]. These utilities are important because bosonic states are often diagnosed through phase-space signatures rather than solely through occupation statistics.

Later work suggests two complementary expansions of this gate-and-measurement layer. On hybrid resonator–qubit hardware, native bosonic operations can be compiled into JC, Rabi, longitudinal, conditional displacement, and conditional beamsplitter gates with depths independent of the boson cutoff for key interactions [2503.11507]. On the software side, a symbolic Hamiltonian compiler has been proposed as a layer above Bosonic Qiskit, translating second-quantized fermion–boson Hamiltonians directly into such gate sequences without first constructing large bosonic matrices [2506.00215]. This suggests a division of labor between a gate-level bosonic circuit model and a Hamiltonian-level symbolic front end.

## 4. Application domains and representative workflows

Bosonic Qiskit was introduced with tutorials and example use cases spanning Jaynes–Cummings dynamics, Bose–Hubbard models, cat-state preparation, Wigner visualization, and maximum-likelihood estimation based on Wigner functions [2209.11153]. These examples reflect the general principle that bosonic hardware and bosonic software abstractions are especially natural when the target Hamiltonian is already written in terms of oscillator operators.

For the Jaynes–Cummings model in the dispersive regime, the Hamiltonian
\[
H = \omega_\mathrm{R} a^\dagger a + \frac{\omega_\mathrm{Q}}{2} \sigma^z + \frac{\chi}{2} \sigma^z a^\dagger a
\]
factorizes into a qumode phase rotation, a qubit \(R_z\) rotation, and a controlled rotation \(e^{-i\chi t \sigma^z a^\dagger a/2}\), each directly supported by the Bosonic Qiskit gate set [2209.11153]. This is an instructive case because the hybrid gate model maps term-by-term onto a familiar cQED Hamiltonian.

For the Bose–Hubbard model,
\[
H = -J\sum_{\langle ij\rangle} \left( a_i^{\dagger}a_j + \mathrm{h.c.} \right)
     + \frac{U}{2} \sum_i \hat{n}_i \left( \hat{n}_i - 1 \right)
     - \mu \sum_i \hat{n}_i,
\]
time evolution is Trotterized into hopping, onsite interaction, and chemical-potential terms [2209.11153]. Hopping maps to a beamsplitter; the chemical-potential term maps to phase rotation; and the quartic onsite interaction can be implemented either by a direct SNAP because \(\hat n_i(\hat n_i-1)\) is diagonal in the Fock basis, or by an approximate Baker–Campbell–Hausdorff synthesis using controlled rotations and an ancilla [2209.11153]. This is a characteristic bosonic-programming pattern: diagonal-in-number nonlinearities become number-selective phases rather than long Pauli-string expansions.

Cat-state preparation illustrates the hybrid measurement workflow. A vacuum qumode is entangled with an ancilla qubit by a controlled displacement, and subsequent qubit measurement in the \(\sigma^x\) basis projects the qumode onto even or odd cat states, whose nonclassical interference structure is then visualized via Wigner functions [2209.11153]. In the cQED error-correction literature, this same family of operations underlies cat-code preparation, parity tracking, and logical control [2008.13471].

Beyond the original tutorials, the broader bosonic-Qiskit literature identifies several further application classes. Bosonic quantum devices have been proposed for molecular vibronic spectra, adiabatic and nonadiabatic chemical dynamics, molecular graph problems, and electronic structure calculations formulated directly in bosonic operators [2404.10214]. The contracted quantum eigensolver has been generalized to many-boson systems by encoding the bosonic wavefunction on qubits through a “bosons as distinguishable hard-core particles” construction, yielding a workflow that is explicitly presented as a “Bosonic Qiskit” implementation route for vibrational Hamiltonians [2307.07088]. Likewise, Gray-code mappings have been used to simulate bosonic interferometric experiments on IBM quantum hardware, giving a qubit-based pathway to “Bosonic Qiskit” when native bosonic hardware is unavailable [2502.01824].

## 5. Relation to bosonic codes, hybrid processors, and compilation layers

Bosonic Qiskit is closely tied to the circuit-QED program of bosonic quantum information processing. In that setting, a bosonic qubit is encoded not in a physical two-level system but in the infinite-dimensional Fock space of a cavity mode, with logical states drawn from binomial, cat, GKP, or related code families [2008.13471]. The dispersive Hamiltonian,
\[
\frac{H}{\hbar} = \omega_c \hat a^\dagger\hat a
 + \frac{\omega_q}{2}\hat\sigma_z
 + \chi \hat a^\dagger\hat a\,\hat\sigma_z,
\]
together with Kerr and SNAP-type control, provides the physical basis for many of the gates exposed in Bosonic Qiskit [2008.13471]. Accordingly, the software can be read as a digital abstraction of bosonic cQED control primitives.

Hybrid resonator–qubit processors make this connection even more explicit. In such devices, resonators serve directly as computational bosonic modes, while transmon qubits provide nonlinearity and control [2503.11507]. For couplings such as
\[
\exp\!\big[i\phi\,\sigma_x(\hat b^\dagger + \hat b)\big],
\]
the resource comparison given for resonator–qubit, unary all-qubit, and binary all-qubit realizations shows that resonator–qubit hardware implements the operation with “2 JC gates,” whereas unary requires \(O(d)\) and binary requires \(O(d^2\log d)\) entangling gates for \(d\) included boson levels [2503.11507]. This supports the general architectural claim that native bosonic backends can avoid the boson-to-qubit mapping overhead that dominates qubit-only approaches.

Hybrid oscillator–qubit frameworks developed for lattice gauge theory and bosonic matter go further by defining extensive gate libraries based on mode rotations, displacements, beamsplitters, controlled number phases, SNAP, conditional displacement, and conditional beamsplitter operations, together with exact decompositions for density–density interactions and gauge-invariant hopping terms [2409.03747]. The same work reports an “improvement of the asymptotic scaling with the boson number cutoff \(S\) from \(\mathcal{O}(\log(S)^2)\) to \(\mathcal{O}(1)\)” for gauge-invariant hopping, and an improvement “from \(\mathcal{O}(\log(S))\) to \(\mathcal{O}(1)\)” for the \(U(1)\) magnetic field term, relative to all-qubit hardware [2409.03747]. These results do not describe Bosonic Qiskit directly, but they define the kind of backend for which a bosonic Qiskit layer is naturally suited.

At the compiler level, the relation is complementary rather than competitive. The symbolic Hamiltonian compiler of Schuckert and collaborators is explicitly positioned as sitting above tools like Bosonic Qiskit: Bosonic Qiskit provides the gate-level programming model and simulation backend, while the compiler performs matrix-free symbolic decomposition of second-quantized fermion–boson Hamiltonians into the native qubit–boson ISA [2506.00215]. That paper states directly that Bosonic Qiskit “enables the assembly of qubit-boson gates but does not directly apply compilation rules to second quantized Hamiltonians” [2506.00215]. This division clarifies a common misconception: Bosonic Qiskit is not, by itself, a full Hamiltonian compiler.

## 6. Alternative meanings, limitations, and future directions

A recurring source of ambiguity is that “Bosonic Qiskit” sometimes denotes native qumode programming, and sometimes denotes qubit-based emulation of bosonic systems. The software package itself adopts the former view by giving bosonic modes an explicit circuit abstraction [2209.11153]. By contrast, the CQE bosonic eigensolver uses a first-quantized particle-orbital encoding in which \(N\) bosons in \(r\) orbitals occupy \(N\times r\) qubits, with bosonic creation operators represented as sums of qubit ladder operators [2307.07088]. Similarly, the Gray-code approach to optical interferometers uses ordinary qubit hardware to encode truncated bosonic Fock states and bosonic operators as Pauli strings [2502.01824]. These are legitimate bosonic-Qiskit workflows, but they do not provide native oscillator registers.

An even more distinct usage appears in hard-core boson circuit simulation. There, multi-qubit circuits are represented algebraically through hard-core boson creation and annihilation operators satisfying bosonic commutativity on different sites and fermion-like exclusion on each site [2606.28004]. The implementation called Quipo is compared directly against IBM Qiskit and is reported to yield “execution times … at least three orders of magnitude smaller than Qiskit’s” on GHZ benchmarks, while also outperforming Qiskit on QFT and entangled QFT up to about 18 qubits in the reported tests [2606.28004]. This does not extend the original Bosonic Qiskit package; rather, it repurposes the phrase to denote a different algebraic backend for ordinary qubit circuits.

The original software also has clear limitations. Truncation errors are intrinsic because modes are represented with finite cutoff \(d=2^k\); large displacements or strong squeezing can produce visibly unphysical artifacts if the cutoff is too small [2209.11153]. Noise modeling was explicitly described as still in progress at publication time, with bosonic-specific, duration-dependent noise channels under development rather than fully integrated into the main branch [2209.11153]. Quadrature measurements are not native measurement primitives, and high-level error-correcting code abstractions are not yet formalized as first-class logical objects [2209.11153].

The forward-looking literature identifies several directions for extension. One is a symbolic, matrix-free Hamiltonian layer that manipulates second-quantized bosonic and hybrid operators algebraically before lowering them to the Bosonic Qiskit gate set [2506.00215]. Another is deeper integration with bosonic codes, including cat, binomial, and GKP encodings, so that logical bosonic qubits become software primitives rather than manually constructed gate sequences [2008.13471]. A further direction is explicit support for resonator–qubit cloud hardware and for noise-aware compilation that treats resonator dissipation not only as an error source but, in open-system simulations, as a parameter defining an effective bosonic bath [2503.11507]. This suggests that the long-term trajectory of Bosonic Qiskit is toward a layered stack: mode-level circuit objects, Hamiltonian-level symbolic compilation, code-level logical abstractions, and backend-specific calibration and noise models.

Taken together, these developments place Bosonic Qiskit at the intersection of continuous-variable software design, bosonic error correction, hybrid qubit–boson hardware, and quantum simulation methodology. Its distinctive role is to make the oscillator Hilbert space programmable within a Qiskit-native environment, whether directly through qumodes or indirectly through closely related bosonic abstractions [2209.11153].

Source: https://www.emergentmind.com/topics/bosonic-qiskit