Bosonic Qiskit: A Hybrid Quantum Toolkit

• Bosonic Qiskit is a hybrid quantum framework that extends Qiskit to simulate systems combining discrete qubits and continuous-variable bosonic modes.
• It implements a specialized gate set—including Gaussian, displacement, and hybrid operations—and provides tools for Wigner-function analysis and phase-space visualization.
• Applications such as Jaynes–Cummings dynamics, Bose–Hubbard models, and cat-state preparation demonstrate its potential to advance quantum simulation and error correction research.

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 (Stavenger et al., 2022). 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 (Stavenger et al., 2022). 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 (Joshi et al., 2020, Decker et al., 30 May 2025).

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” (Stavenger et al., 2022). 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” (Stavenger et al., 2022). 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” (Stavenger et al., 2022).

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 (Stavenger et al., 2022). 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” (Decker et al., 30 May 2025). 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 (Joshi et al., 2020). 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 (Emmanuel-Costa et al., 26 Jun 2026).

This terminological plurality matters because it separates at least three layers. First, there is a concrete SDK extension centered on QumodeRegister and CVCircuit (Stavenger et al., 2022). Second, there is a broader architectural notion of a Qiskit-like environment whose primitive register is bosonic rather than purely qubit-based (Joshi et al., 2020). Third, there are higher-level compiler and simulation backends that either sit above Bosonic Qiskit or reinterpret its role in more specialized settings (Decker et al., 30 May 2025, Emmanuel-Costa et al., 26 Jun 2026). 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. (Stavenger et al., 2022). 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$ (Stavenger et al., 2022).

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 $d=2^k$1 which produces a single qumode with cutoff $d=64$ (Stavenger et al., 2022). 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 (Stavenger et al., 2022).

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 (Stavenger et al., 2022).

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 (Stavenger et al., 2022). 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	$\{|n\rangle\}_{n=0}^\infty$0	cv_r
Displacement	$\{|n\rangle\}_{n=0}^\infty$1	cv_d
Single-mode squeezing	$\{|n\rangle\}_{n=0}^\infty$2	cv_sq
Two-mode squeezing	$\{|n\rangle\}_{n=0}^\infty$3	cv_sq2
Beamsplitter	$\{|n\rangle\}_{n=0}^\infty$4	cv_bs
Controlled rotation	$\{|n\rangle\}_{n=0}^\infty$5	cv_c_r
Controlled displacement	$\{|n\rangle\}_{n=0}^\infty$6	cv_c_d
Controlled beamsplitter	$\{|n\rangle\}_{n=0}^\infty$7	cv_c_bs
SNAP	$\{|n\rangle\}_{n=0}^\infty$8	cv_snap
Exponential SWAP	$\{|n\rangle\}_{n=0}^\infty$9	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 (Stavenger et al., 2022). 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 (Joshi et al., 2020).

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 (Stavenger et al., 2022). 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 (Stavenger et al., 2022). 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 (Stavenger et al., 2022).

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 (Stavenger et al., 2022). 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 (Leppäkangas et al., 14 Mar 2025). 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 (Decker et al., 30 May 2025). 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 (Stavenger et al., 2022). 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

$a,a^\dagger$0

factorizes into a qumode phase rotation, a qubit $a,a^\dagger$1 rotation, and a controlled rotation $a,a^\dagger$2, each directly supported by the Bosonic Qiskit gate set (Stavenger et al., 2022). This is an instructive case because the hybrid gate model maps term-by-term onto a familiar cQED Hamiltonian.

For the Bose–Hubbard model,

$a,a^\dagger$3

time evolution is Trotterized into hopping, onsite interaction, and chemical-potential terms (Stavenger et al., 2022). 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 $a,a^\dagger$4 is diagonal in the Fock basis, or by an approximate Baker–Campbell–Hausdorff synthesis using controlled rotations and an ancilla (Stavenger et al., 2022). 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 $a,a^\dagger$5 basis projects the qumode onto even or odd cat states, whose nonclassical interference structure is then visualized via Wigner functions (Stavenger et al., 2022). In the cQED error-correction literature, this same family of operations underlies cat-code preparation, parity tracking, and logical control (Joshi et al., 2020).

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 (Dutta et al., 2024). 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 (Wang et al., 2023). 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 (Brasil et al., 3 Feb 2025).

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 (Joshi et al., 2020). The dispersive Hamiltonian,

$a,a^\dagger$6

together with Kerr and SNAP-type control, provides the physical basis for many of the gates exposed in Bosonic Qiskit (Joshi et al., 2020). 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 (Leppäkangas et al., 14 Mar 2025). For couplings such as

$a,a^\dagger$7

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 $a,a^\dagger$8 and binary requires $a,a^\dagger$9 entangling gates for $\hat n=a^\dagger a$0 included boson levels (Leppäkangas et al., 14 Mar 2025). 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 (Crane et al., 2024). The same work reports an “improvement of the asymptotic scaling with the boson number cutoff $\hat n=a^\dagger a$1 from $\hat n=a^\dagger a$2 to $\hat n=a^\dagger a$3” for gauge-invariant hopping, and an improvement “from $\hat n=a^\dagger a$4 to $\hat n=a^\dagger a$5” for the $\hat n=a^\dagger a$6 magnetic field term, relative to all-qubit hardware (Crane et al., 2024). 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 (Decker et al., 30 May 2025). 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” (Decker et al., 30 May 2025). 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 (Stavenger et al., 2022). By contrast, the CQE bosonic eigensolver uses a first-quantized particle-orbital encoding in which $\hat n=a^\dagger a$7 bosons in $\hat n=a^\dagger a$8 orbitals occupy $\hat n=a^\dagger a$9 qubits, with bosonic creation operators represented as sums of qubit ladder operators (Wang et al., 2023). Similarly, the Gray-code approach to optical interferometers uses ordinary qubit hardware to encode truncated bosonic Fock states and bosonic operators as Pauli strings (Brasil et al., 3 Feb 2025). 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 (Emmanuel-Costa et al., 26 Jun 2026). 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 (Emmanuel-Costa et al., 26 Jun 2026). 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$0; large displacements or strong squeezing can produce visibly unphysical artifacts if the cutoff is too small (Stavenger et al., 2022). 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 (Stavenger et al., 2022). Quadrature measurements are not native measurement primitives, and high-level error-correcting code abstractions are not yet formalized as first-class logical objects (Stavenger et al., 2022).

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 (Decker et al., 30 May 2025). 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 (Joshi et al., 2020). 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 (Leppäkangas et al., 14 Mar 2025). 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 (Stavenger et al., 2022).