Fulqrum: a generalized framework for quantum subspace diagonalization
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.
Kai: We're looking at the paper: "Fulqrum: a generalized framework for quantum subspace diagonalization".
Mira: Here's the gist of the paper. A generalized framework for quantum subspace diagonalization is presented to compute solutions to Hamiltonian eigenproblems in a subspace defined by bit-strings sampled from a quantum computer Eigenvalue problems represent one of the mainstay calculations for near-term
1, 2: and fault-tolerant
3–7: quantum applications, including domains such as quantum chemistry
8, 9: and quantum optimization
10: These methods aim to solve eigenproblems of the form Hˆ ψj ⟩ = λj ψj ⟩, or the generalized version Hˆ ψj ⟩ = λjMψj ⟩, where M is a possible modal matrix
2603.18731> The state ψj ⟩ is defined in a subspace spanned by the counts returned from sampling one or more quantum circuits on a quantum processor Framework Capabilities The framework, called Fulqrum [2603.18731: , provides a unified solution method for both qubit and fermionic QSD by efficiently casting fermionic problems to qubit Hamiltonians using an extended alphabet that includes projection and ladder operators Utilizing bit-sets for computational basis states allows the method to have no fundamental limit on the number of allowed qubits The framework does not perform eigensolving itself but generates canonical matrix representations compatible with a wide range of existing numerical methods Performance Gains The framework demonstrates performance that is better than widely used frameworks in terms of both time-to-solution and memory consumption For the antiferromagnetic XXZ spin-1/2 chain Heisenberg model, Fulqrum was found to be over and order of magnitude faster than qiskit-addon-sqd, with the difference in projection timings diverging as the number of qubits and bit-strings grows Furthermore, for fermionic Hamiltonians like N2 and CH4 dimer, Fulqrum outperformed Dice in terms of both solution time and peak memory consumption Optimization Techniques The framework incorporates several techniques to enhance performance, including the use of a "fast" CSR matrix building mode which utilizes an array of dynamically allocated C++ vectors for column indices and matrix-element values in a single step The Recursive Algorithm (RAMPS) is used to prune the subspace to only those bit-strings that impact the final eigenenergy by more than a user supplied tolerance value Additionally, an efficient upper / lower triangle evaluation method allows for computing only lower/upper triangle matrix elements without explicit column bit-set computation Implementation Details The implementation is primarily written in C++17 with parallelism provided by OpenMP and Python bindings utilizing Cython
2603.18731: The workflow partitions into Hamiltonian representations, subspace data structure, and matrix evaluation Hamiltonian representations involve representing qubit Hamiltonians using an extended alphabet that includes projection and ladder operators Fermionic systems are cast to equivalent qubit representations via a Jordan-Wigner (JW) transformation [2603.
Title and authors: Kai: We've looked at the title and authors of Fulqrum, and it’s clear this paper is positioning itself as a generalized solution, which Mira mentioned earlier. It’s not just a tool for one specific problem type, but something that tries to cover both qubits and fermions under one umbrella.
Mira: Exactly. The authors are trying to build a unified language for solving Hamiltonian eigenproblems by using an extended alphabet that incorporates projection and ladder operators, which is the core idea behind Fulqrum: a generalized framework for quantum subspace diagonalization.
Lev: It’s ambitious because unifying qubit and fermionic systems often requires fundamentally different mathematical approaches, so I'm wondering how they manage that transition smoothly without losing accuracy in the mapping process.
Kai: They tackle that by casting fermionic problems into equivalent qubit representations using a Jordan-Wigner transformation, which is a standard way to relate those two worlds. But the paper suggests their extended alphabet handles the projection and ladder operators directly in this mapping, which is cleaner than just applying the transformation afterward.
Mira: That sounds like they are building their structure into the transformation itself rather than just slapping a conversion layer on top. It implies a more inherent connection between how we describe these two types of quantum systems at the operator level.
Lev: I’m still concerned about the practical cost of that unified alphabet. If those extended operators require many more steps or operations per term compared to simple Pauli matrices, the speed advantage might vanish quickly when we actually run a long simulation.
Kai: The authors address that by grouping and sorting these operators so that they only evaluate the non-zero terms and perform a minimal number of subspace lookup operations. They’re trying to keep the computational cost low by being smart about which parts of the Hamiltonian they even bother looking at.
Mira: So, it’s not just about having more tools; it’s about making sure you only use the necessary tools for a given problem structure, which is a very practical approach for simulation. It moves away from brute-force application of every possible operator to something more targeted.
Lev: That targeting sounds good, but I need to see if their minimal lookup operations actually translate into a real speedup on hardware when we move from the theoretical description to the actual execution flow, especially when dealing with large Hilbert spaces.
Kai: The results section validates this by showing that this unified approach leads to over an order of magnitude faster performance than qiskit addon sqd for the antiferromagnetic XXZ spin-one/two chain Heisenberg model, and that difference in projection timings grows with problem size <ref:2603.18731#pg1>.
Mira: That comparison against a known solver like qiskit addon sqd gives us a solid benchmark to judge the efficiency claims. It's not just theoretical speed; it’s measured performance on a specific, well-understood problem.
Lev: So, the implication is that for problems where we can define these structures cleanly—like the XXZ model—this framework offers a clear advantage over existing generalized methods when scaling up the size of the system.
Kai: Right, so they’re showing that their construction is efficient enough to handle complexity better than what we currently have available in standard quantum computing software packages. This points toward a more scalable approach for running these kinds of calculations on actual hardware later on.
Mira: It suggests that the way we structure the Hamiltonian representation matters a lot, and Fulqrum provides a structured way to do that which is beneficial across different physical systems. Now, let’s look at what they actually claim this framework can achieve in practice.
The paper's summary: Kai: So, summarizing what the paper actually does with this framework, it’s providing a unified solution method for both qubit and fermionic problems by efficiently casting fermionic problems into qubit Hamiltonians. It uses bit-sets to handle the massive state space and allows you to directly construct sparse matrix representations or get matrix-free solutions.
Mira: That's the practical takeaway: they aren't just proposing a new algorithm; they are giving us a way to generate canonical matrix representations that are compatible with a wide range of existing numerical methods, which is crucial for usability.
Lev: The key thing I’m hearing is that because it generates these sparse representations, the memory size of the actual matrix needed for diagonalization doesn't explode to the point where it becomes completely impractical to store on current hardware. That’s a major relief from an engineering perspective.
Kai: They also highlight how they use bit-sets specifically to reduce memory consumption while maintaining no fundamental limit on the number of qubits you can define in your problem setup, which is a huge structural improvement for scaling problems.
Mira: So, it’s about achieving better scaling across qubit counts by using this specific bit-set representation instead of simpler integer methods. It allows the method to handle much larger systems before memory becomes the limiting factor.
Lev: I need to know how they handle the fermionic Hamiltonians specifically, because that’s where things get tricky. They use an extended Jordan-Wigner transformation, which maps projection and ladder operators directly into qubit terms. That seems like a very direct way to make the connection explicit for fermionic systems.
Kai: Precisely. And they also have these performance enhancements built in, like using RAMPS to prune the subspace down only to those bit-strings that matter beyond a user-supplied tolerance value, which cuts down on redundant calculations significantly.
Mira: So it’s a combination of structural representation improvements—bit-sets and extended transformations—with algorithmic pruning techniques like RAMPS, all aimed at improving both speed and memory efficiency in the subspace diagonalization process.
Lev: It seems like the authors have done a lot of heavy lifting on making sure that these improvements aren't just theoretical tricks but are actually reflected in practical performance gains when you run them on test Hamiltonians.
Kai: They validate this by showing that for fermionic Hamiltonians like N2 and CH4 dimer, their method outperformed Dice in both solution time and peak memory consumption. That’s a pretty strong comparison against another existing tool for that specific domain.
Mira: So, it seems the summary is that Fulqrum offers a more robust way to approach this problem by combining representation flexibility with targeted algorithmic pruning for better practical results. It's about making the process more efficient end-to-end.
The paper's improvements: Kai: Now let’s talk about the specific improvements they suggest in Fulqrum, because it’s not just a framework; it has several specific tweaks designed to boost performance. One is the use of a "fast" CSR matrix building mode that uses an array of dynamically allocated C++ vectors for column indices and matrix-element values in one single step.
Mira: That sounds like they are optimizing the actual process of assembling the matrix structure itself, which is usually a bottleneck when dealing with sparse matrices on large systems. They’re trying to make that setup phase much quicker.
Lev: I like that because for real hardware, matrix construction time can eat up a lot of cycles if it's not optimized. If they can do that in one step using C++ vectors, it should reduce the overhead significantly compared to iterative building processes.
Kai: They also have the RAMPS algorithm mentioned again, which is used to prune the subspace by only keeping bit-strings that impact the final eigenenergy beyond a tolerance value you supply. This is a powerful way to control complexity during the calculation.
Mira: That pruning technique, using RAMPS, gives us flexibility because we can tune that tolerance level. It lets users trade accuracy for speed in specific parts of the calculation, which is exactly what you need when exploring complex physical systems like those they test with fermionic Hamiltonians.
Lev: And they have this efficient upper or lower triangle evaluation method that exploits the structure of the Hamiltonian by checking just the most significant off-diagonal bit in a row bit-set to decide if a matrix element belongs in the lower or upper triangle.
Kai: That sounds like a very clever way to avoid calculating redundant matrix elements, which should lead to substantial savings in computation time during the actual diagonalization phase. It’s exploiting the structure of the problem itself.
Mira: It seems like they are using structural knowledge about how these operators interact—how they map onto bit-sets—to intelligently skip calculations that don't need to be done, which is a form of smart complexity management.
Lev: So, these improvements—the fast building mode, the RAMPS pruning, and the triangle evaluation trick—they all seem designed to tackle the computational bottlenecks in both setup and execution phases of subspace diagonalization.
Kai: Exactly. They’re showing that by combining structural representation choices with targeted algorithmic pruning, you can get better runtime and memory efficiency simultaneously than what was previously achieved.
Mira: So, the implication is that we don't just need a bigger quantum computer; we need smarter software frameworks to handle the complexity of defining and solving these problems effectively on smaller or noisier devices.
Conclusion: Kai: To wrap up this talk on Fulqrum: the main idea is that it provides a generalized framework for solving Hamiltonian eigenproblems in a subspace defined by sampled bit-strings, proving it can be faster and use less memory than some current implementations on test models.
Mira: It’s about providing users with canonical matrix representations that are compatible with existing numerical methods, which makes the tool much more accessible for applying to diverse applications in quantum chemistry or optimization.
Lev: From my side, the most important thing is that the results show a clear scaling advantage over qiskit addon sqd as problem sizes grow, which suggests this framework has a better path toward practical use on real hardware when we move past toy problems.
Kai: So, it’s about demonstrating that by using bit-sets and intelligent pruning techniques like RAMPS, you can manage the complexity of large problems while maintaining good performance metrics across different system types.
Mira: It’s a step toward making simulation tools more efficient for real-world use because they handle the structural complexity of both qubits and fermions in one cohesive way.
Lev: I just hope that as we move to larger, more complex physical systems, this framework can maintain its performance profile without hitting some unknown hardware limitations we haven't accounted for yet.
Kai: That’s the challenge ahead—seeing how well it holds up when we introduce real noise and connectivity into the simulation environment. It’s a good foundation for future work in applying these concepts to real quantum computation problems.
IBM Quantum · IBM T J Watson Research Center · IBM Research Cambridge
quant-ph
Submitted: 2026-03-19
Updated: 2026-11-10
Comments: 25 pages, 6 figures, 3 tables, 1 algorithm
Code: https://github.com/qiskit-community/fulqrum
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 100/100
The gist: A generalized framework for quantum subspace diagonalization is presented to compute solutions to Hamiltonian eigenproblems in a subspace defined by bit-strings sampled from a quantum computer…
Key concepts
- Generalized Framework
- Fulqrum is a unified method designed to solve Hamiltonian eigenproblems for both qubit and fermionic systems. It achieves this by using an extended alphabet that incorporates projection and ladder operators, providing a single approach applicable across different quantum system types.
- Bit-Sets for Qubits
- Instead of using standard integers to represent qubit states, Fulqrum uses bit-sets. This technique allows the framework to handle an arbitrarily large number of qubits without fundamental limits on the size of the allowed state space, ensuring scalability for complex quantum problems.
- RAMPS Algorithm
- RAMPS is a recursive algorithm used to prune the subspace during diagonalization. It selectively keeps only those bit-strings that significantly impact the final eigenenergy based on a user-defined tolerance, effectively reducing computation time by focusing on the most relevant parts of the problem.
Terminology
Summary
A generalized framework for quantum subspace diagonalization is presented to compute solutions to Hamiltonian eigenproblems in a subspace defined by bit-strings sampled from a quantum computer
Eigenvalue problems represent one of the mainstay calculations for near-term [1, 2] and fault-tolerant [3–7] quantum applications, including domains such as quantum chemistry [8, 9] and quantum optimization [10] These methods aim to solve eigenproblems of the form Hˆ ψj ⟩ = λj ψj ⟩, or the generalized version Hˆ ψj ⟩ = λjMψj ⟩, where M is a possible modal matrix [2603.18731> The state ψj ⟩ is defined in a subspace spanned by the counts returned from sampling one or more quantum circuits on a quantum processor
Framework Capabilities
The framework, called Fulqrum [2603.18731], provides a unified solution method for both qubit and fermionic QSD by efficiently casting fermionic problems to qubit Hamiltonians using an extended alphabet that includes projection and ladder operators Utilizing bit-sets for computational basis states allows the method to have no fundamental limit on the number of allowed qubits The framework does not perform eigensolving itself but generates canonical matrix representations compatible with a wide range of existing numerical methods
Performance Gains
The framework demonstrates performance that is better than widely used frameworks in terms of both time-to-solution and memory consumption For the antiferromagnetic XXZ spin-1/2 chain Heisenberg model, Fulqrum was found to be over and order of magnitude faster than qiskit-addon-sqd, with the difference in projection timings diverging as the number of qubits and bit-strings grows Furthermore, for fermionic Hamiltonians like N2 and CH4 dimer, Fulqrum outperformed Dice in terms of both solution time and peak memory consumption
Optimization Techniques
The framework incorporates several techniques to enhance performance, including the use of a fast
CSR matrix building mode which utilizes an array of dynamically allocated C++ vectors for column indices and matrix-element values in a single step The Recursive Algorithm (RAMPS) is used to prune the subspace to only those bit-strings that impact the final eigenenergy by more than a user supplied tolerance value Additionally, an efficient upper / lower triangle evaluation method allows for computing only lower/upper triangle matrix elements without explicit column bit-set computation
Implementation Details
The implementation is primarily written in C++17 with parallelism provided by OpenMP and Python bindings utilizing Cython [2603.18731] The workflow partitions into Hamiltonian representations, subspace data structure, and matrix evaluation Hamiltonian representations involve representing qubit Hamiltonians using an extended alphabet that includes projection and ladder operators Fermionic systems are cast to equivalent qubit representations via a Jordan-Wigner (JW) transformation [2603. p. 5 Bit-strings sampled from a quantum processing unit (QPU), with optional postprocessing such as SQD, are used to construct a Subspace instance that, together with a corresponding qubit (QubitOperator) or
fermionic (FermionicOperator) Hamiltonian representation, are used to build a SubspaceHamiltian model. Fermionic systems
are cast to equivalent qubit representations via an extended-alphabet JW transformation for a unified solution method.Where the paper says it
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Faster performance for quantum subspace diagonalization by utilizing a unified solution method for qubit and fermionic systems through an extended alphabet that includes projection and ladder operators, allowing for
a unified solution method for qubit and fermionic systems.
-
Reduced memory consumption in eigensolving by employing a generalized framework called Fulqrum that generates canonical matrix representations compatible with existing numerical methods, which can be used to construct
sparse matrix representations or obtain matrix-free solutions.
-
Scalability across qubit counts by expressing bit-strings using bit-sets instead of integers, allowing for
no fundamental limit on the number of allowed qubits
in the framework. -
Improved runtime and memory efficiency by leveraging a recursive algorithm called RAMPS to generate a Minimal Perturbative Subspace, which is
nominally larger than the initial
but can be modified to terminate after a maximum number of recursions while maintaining accuracy. -
Enhanced performance for fermionic systems by casting them into equivalent qubit representations via an extended Jordan-Wigner transformation that maps projection and ladder operators directly into their qubit counterparts.
-
Optimized matrix evaluation by exploiting the structure of the Hamiltonian, specifically checking just the most significant off-diagonal bit (MSOB) in a row bit-set to determine if a matrix element belongs in the lower or upper triangle, allowing for
a ∼ 10x decrease in the runtime for matrix construction of fermionic systems.
-
Flexible eigensolving by providing users with the choice of classical eigensolver, enabling optimization through methods such as
matrix-free evaluation and the RAMPS procedure introduced here.
Abstract
We present an open-source software framework for computing the solution to Hamiltonian eigenproblems in a subspace defined by bit-strings sampled from a quantum computer. Hamiltonians are represented using an extended alphabet that includes projection and ladder operators, yielding a unified solution method for qubit and fermionic systems. Operators are grouped and sorted so that only non-zero terms need be evaluated and a minimal number of subspace lookup operations performed. Bit-strings are expressed using bit-sets to reduce memory consumption and allow for evaluating operators with no fundamental limit on the number of qubits. Subspaces defined over bit-sets are stored in a hash map format that allows for efficient indexing and lookup operations. Specializations for problems, such as those from quantum chemistry, can further reduce computational costs. Our method can be used to directly construct sparse matrix Hamiltonian representations or obtain matrix-free solutions, allowing users to utilize their eigensolver of choice. We show the benefits of our framework by computing the ground-state solution to examples from condensed matter physics and quantum chemistry with less memory and runtime compared to existing techniques, in some cases by two orders of magnitude or more. This work provides a flexible interface for performant quantum-classical eigensolutions for candidate quantum advantage applications.
Sources
- Quantum measurements and the Abelian Stabilizer Problem
- Subspace methods for electronic structure simulations on quantum computers
- Quantum-Selected Configuration Interaction: classical diagonalization of Hamiltonians in subspaces selected by quantum computers
- Chemistry Beyond the Scale of Exact Diagonalization on a Quantum-Centric Supercomputer
- Hamiltonian simulation-based quantum-selected configuration interaction for large-scale electronic structure calculations with a quantum computer
- HIVQE: Handover Iterative Variational Quantum Eigensolver for Efficient Quantum Chemistry Calculations
- Quantum-Centric Algorithm for Sample-Based Krylov Diagonalization
- Quantum-centric simulation of hydrogen abstraction by sample-based quantum diagonalization and entanglement forging
- Scaling active spaces in simulations of surface reactions through sample-based quantum diagonalization
- Enhancing the accuracy and efficiency of sample-based quantum diagonalization with phaseless auxiliary-field quantum Monte Carlo
- Closed-loop calculations of electronic structure on a quantum processor and a classical supercomputer at full scale
- OpenFermion: The Electronic Structure Package for Quantum Computers
- PennyLane: Automatic differentiation of hybrid quantum-classical computations
- Qrisp: A Framework for Compilable High-Level Programming of Gate-Based Quantum Computers
Related papers
- Computational regimes in matrix-product-state-based quantum trajectory simulations
- Toward chemically accurate quantum simulations on quantum hardware: A quantum-HPC hybrid approach
- Transversal surface-code game with reconfigurable qubits
- Flux-Activated Resonant Control of a Bosonic Quantum Memory
- Machine learning the effects of many quantum measurements
- Barriers to dequantization of near-term molecular electronic structure methods