Qiskit Fermions: a modular toolbox for fermionic systems

Computing the properties of molecules and materials requires solving the quantum behavior of interacting fermionic particles. Quantum simulation of these systems is one of the most promising applications of quantum computing, but there is a disconnect between the fermionic problems researchers want to express—from operators and Hamiltonians to time dynamics—and the qubit-based circuits a quantum computer actually runs. Bridging that divide, without throwing away the structure of the problem in the process, is challenging.

Today, we're introducing Qiskit Fermions, a new research capability that provides a flexible framework for working with fermionic systems directly, enabling more advanced mappings of fermionic systems to qubit representations. Qiskit Fermions is an open-source tool for expressing fermionic operators and circuits, defining fermion-to-qubit mappings, and compiling fermionic workflows into quantum circuits.

We created Qiskit Fermions to address a clear gap in the quantum software ecosystem: the absence of a dedicated, modern framework for defining and working with fermionic systems. But our ambition went further than merely filling that gap. We also set out to build a powerful, versatile toolbox that serves researchers across a full spectrum of needs and use cases.

Qiskit Fermions empowers you to conduct cutting-edge research—developing new mappings, encodings, and algorithms on top of the package—in a way that leads to robust, reusable implementations. At the same time, it ships with efficient, pre-built components for completing the tasks you’ll reach for most often, so you can get up and running right away.

Whether you’re building entirely new fermionic workflows or looking to apply ready-made tools to problems in fields like quantum chemistry, condensed-matter physics, or materials science, Qiskit Fermions is designed to support your work without getting in the way.

Qiskit Fermions is part of a broader collection of modular tools IBM is building for mapping domain-specific problems to qubit operators and quantum-circuit representations. Another example in this family is the package released last year for mapping optimization problems.

Mapping tools like these help accelerate the exploration and design of new algorithms. They provide modular building blocks for end-to-end quantum workflows, while remaining composable and integrating seamlessly with complementary tools across the software stack.

What makes Qiskit Fermions different?

Qiskit Fermions is a toolbox for expressing fermionic operators, constructing fermionic circuits, and defining the mappings between fermionic and qubit systems. Its core capabilities include the representation of fermionic operators and circuits, fermion-to-qubit synthesis, Qiskit transpiler integration, and support for pluggable encoding workflows.

It includes a library of efficient, Rust-based mappings that are ready to use, and it also functions as a workflow that lets you implement mappings of your own. The goal is to drive the development of the fermionic algorithms you care about, without imposing constraints on how you work.

That flexibility is reflected in the package’s modular design. Qiskit Fermions provides efficient methods for the most common tasks, while also enabling researchers to explore new mappings, experiment with different encodings, investigate fermionic systems, and develop application algorithms. It gives you the tools to express all of that on your own terms.

More specifically, the package covers:

• Operator representations, along with a framework and library for converting between them
• Fermionic circuits that act on fermionic modes rather than qubits
• Mapping frameworks for transitioning from fermions to qubits, with efficient library mappers and a straightforward path to writing your own
• Transpiler integration, so fermionic circuits plug directly into the Qiskit transpiler pipeline

What is a fermionic circuit?

The central premise of Qiskit Fermions is the idea of the fermionic circuit—a domain-specific representation for expressing computations in fermionic space. A fermionic circuit looks like a quantum circuit, but it acts on fermionic modes rather than qubits. That distinction matters because of when the fermion-to-qubit mapping occurs.

As a concrete example, let’s consider a time-evolution simulation. In the traditional approach, you map the fermionic Hamiltonian to qubits first, then implement the time evolution of the resulting operators.

However, recent research shows that reversing this order can be advantageous: you perform the time evolution of the fermionic operator first, and map to qubits afterward. Delaying the mapping until the transpilation process makes it substantially more straightforward to implement local encodings and to take advantage of ancilla qubits, enabling circuit optimizations that can reduce two-qubit gate depth dramatically.

Qiskit Fermions makes this a first-class workflow. It builds on the multi-representation compiler framework introduced in Qiskit v2.5, which allows a single compilation pipeline to move between different intermediate representations. A computation begins as a fermionic operator and fermionic circuit; the fermion-to-qubit synthesis then takes place partway through transpilation; and from there, the pipeline continues with standard quantum circuits at the qubit level.

Because information about fermionic symmetries is carried much further into the pipeline, you can achieve levels of optimization that are unavailable once a computation has been reduced to qubit-level operators. This opens the door to symmetry-aware transpilation.Rustiq is a transpilation plugin that exploits symmetries to reduce circuit depth. Qiskit Fermions does not yet offer a full equivalent, but because it operates at the fermionic level before lowering to qubits, it should make even more effective optimizations of this kind possible.

Qiskit Fermions in action: constant-depth Fermi-Hubbard dynamics

For a clear illustration of this concept, we can take a look at time dynamics of the 1D Fermi-Hubbard model. It’s an approachable example that demonstrates the full workflow: you build an operator, define your own encoding, and plug that encoding into the transpiler to achieve a meaningful reduction in circuit depth.

The full guide in our documentation walks through every step. Here, we cover the highlights.This walkthrough uses the Python API. The fermionic-circuit and synthesis features shown here are currently Python-only, with equivalent C support planned for a future release.

First, install the package:

pip install qiskit-fermions

You’ll express the Hamiltonian at the fermionic level as a TransferVertexOperator. This operator combines vertex operators, which measure the occupation of each mode, with transfer operators, which move a fermion along a directed edge of the interaction graph:

from qiskit_fermions.operators import TransferVertexOperator

# 1D Fermi-Hubbard on 4 sites, assembled directly as a TransferVertexOperator.
hamiltonian = fermi_hubbard_1d(num_sites=4, tunneling=1.0, interaction=2.0)

You’ll then add that operator to a fermionic circuit as a single evolution gate—one operation acting on fermionic modes rather than qubits:

from qiskit_fermions.circuit import FermionicCircuit
from qiskit_fermions.circuit.library import Evolution

circuit = FermionicCircuit(num_modes=4)
circuit.append(Evolution(num_modes=4, hamiltonian, time=0.5), circuit.modes)

The benefit comes from how that gate is converted into qubits. Qiskit Fermions exposes this fermion-to-qubit synthesis as two interchangeable components: the encoding that defines how fermions map to qubits, and the method used to approximate the time evolution. Researchers can supply their own for either one.

For this model, adding a single ancilla qubit lets the encoding convert an entire set of the model's hopping terms—the terms describing particles moving between sites—into simple single-qubit operations. As a result, the two-qubit depth of a single time-evolution step remains constant, regardless of how many sites you simulate. This is possible because of a technique known as flow sets.What are flow sets? Flow sets group the Hamiltonian's terms before the mapping to qubits, rather than after. Spending one extra qubit then turns an entire group of hopping terms into single-qubit rotations that require no entangling gates—an example of how investing additional qubits can buy structural simplicity in the resulting circuit.

Measuring the two-qubit depth from 4 sites up to 100—well beyond what can be simulated by brute force classical computation—makes the difference concrete:

The depth remains constant at 12 across the entire range. A conventional Jordan-Wigner-based approach, by contrast, naively Trotterizes each term of the Hamiltonian individually after mapping to qubits, causing circuit depth to grow with system size, reaching 407 at 100 sites.

The flow-set approach instead groups terms deliberately before synthesis, ensuring that each group can be implemented at constant depth. Without a framework that preserves and exposes this fermionic structure during compilation, achieving a constant-depth result of this kind would require building the circuits by hand, an approach that becomes impractical at these system sizes and does not scale well to larger problems.

Importantly, this is a general, pluggable framework rather than a solution specific to the 1D Fermi-Hubbard model. The same components extend to the 2D Fermi-Hubbard model and beyond, and they support research built on whatever encodings you choose to investigate. Qiskit Fermions is designed as a foundation for researchers to build upon.

That said, you don’t need to write a custom encoding to get started. For a sensible default, a preset Jordan-Wigner pass manager can take you from a fermionic circuit to a qubit circuit in a single call. The full flexibility is there for researchers who want it, while the most common workflows remain simple and accessible.

The modular design also lends itself to AI-assisted development. Because the core data structures are stable and the encoding and synthesis components are cleanly pluggable, a coding agent can prototype and test new methods quickly. The 1D Fermi-Hubbard guide referenced in this post, for example, was largely generated by a coding agent working from the underlying research paper¹ in a single session.

How does Qiskit Fermions connect to the broader Qiskit ecosystem?

Qiskit Fermions is designed to operate as part of a larger workflow. It plugs directly into the Qiskit transpiler pipeline, and it also connects to many of the simulators and quantum subspace diagonalization tools that researchers already rely on.

For example, Qiskit Fermions integrates natively with ffsim, a high-performance simulator that serves as an important workload-validation tool for researchers developing and testing fermionic workflows.

ffsim lets you simulate fermionic circuits directly at the fermionic level, which is more efficient than simulating at the qubit level. That’s because it represents the quantum state far more compactly. Rather than simulating the full qubit Hilbert space of possibilities, it works in the smaller fermionic Fock space, which contains only the physically relevant configurations.

This applies to circuits that preserve particle number; circuits that do not satisfy those requirements can be transpiled to qubits and simulated using conventional qubit-level simulators instead.

ffsim is an optional dependency that accelerates certain operations. Simulating an orbital-rotation gate, for instance, is faster with ffsim than with the built-in SciPy path. When ffsim is not installed, simulation falls back to a native path, so your workflow continues to run.

The ffsim integration points to a broader pattern: Qiskit Fermions is built to be combined with other tools into complete, end-to-end workflows.

For example, let’s say you have an eigenvalue problem, such as finding the ground-state energy of a molecule. You can construct fermionic circuits with Qiskit Fermions, sample from them with a quantum computer, and pass the results to a quantum subspace diagonalization tool like the SQD (sample-based quantum diagonalization) addon to estimate a system’s energy.What is SQD? Sample-based quantum diagonalization, or SQD, is a noise-robust technique that estimates a quantum system's eigenvalues (e.g., ground state energy) by classically processing samples drawn from a circuit on quantum hardware. The SQD addon is an open-source package that implements this technique and Qiskit Fermions can generate the circuits that SQD processes samples from downstream.

Qiskit Fermions also unlocks other workflows from the ecosystem. A good example is SqDRIFT², which benefits from having its circuits expressed directly at the fermionic level in two ways:

1. The fermionic-level qDRIFT randomization can be implemented as a simple transpiler pass.
2. ffsim can be used for verification and pipeline testing of these circuits before they are mapped to qubits.

It is even possible to implement transpiler passes that directly impact the fermion-to-qubit routing before the fermion-to-qubit synthesis takes effect, potentially resulting in drastic reductions in two-qubit gate count.

What's next for Qiskit Fermions?

Qiskit Fermions is a direct contribution to our work developing what we call "utility mapping tools”: reusable software components that translate domain-specific problem descriptions into representations suitable for quantum computing. Looking ahead, the package will integrate more closely with sample-based diagonalization tools as they mature, including more direct support for converting Qiskit fermionic operators into the forms those tools require.

We’ve also positioned Qiskit Fermions to integrate more deeply with existing scientific software. Like the Qiskit SDK itself, it is built on a high-performance Rust core with both Python and C APIs, enabling seamless installation across all Qiskit-supported platforms while providing a foundation for interoperable high-performance tooling.

As Qiskit adds support for custom gates and circuit types in C, together with a C-native transpilation workflow, we will be able to port the Qiskit Fermions circuit library into Rust—and therefore into C as well. This will allow existing chemistry and materials science codes to couple directly to fermionic workflows and compile them into Qiskit.

Get started

Qiskit Fermions is open source and available now.

• Documentation and guides: installation instructions, the full 1D and 2D Fermi-Hubbard walkthroughs, and API references
• qiskit-fermions GitHub repo: the open-source package
• Research paper on flow-set encodings: the theoretical foundation for the 1D Fermi-Hubbard example discussed in this post
• ffsim: a high-performance simulator for validating and testing fermionic workflows directly at the fermionic level
• SqDRIFT research paper: example of a workflow that benefits from operating on fermionic circuit representations prior to fermion-to-qubit synthesis

We're excited to see what you build with Qiskit Fermions. Try it out and let us know what you discover.