⚛️ quantum physics

A generalized framework for quantum subspace diagonalization

This paper introduces a memory-efficient and scalable quantum-classical framework for solving Hamiltonian eigenproblems by utilizing bit-set representations and hash maps to unify qubit and fermionic systems, significantly reducing runtime and memory usage compared to existing techniques.

Original authors: Paul D. Nation, Abdullah Ash Saki, Hwajung Kang

Published 2026-03-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Paul D. Nation, Abdullah Ash Saki, Hwajung Kang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to find the lowest point in a vast, foggy mountain range. In the world of quantum physics, this "lowest point" is called the ground state, and finding it tells us the most stable energy of a molecule or a material. This is crucial for designing new drugs, better batteries, or understanding how materials work.

However, the mountain range is so huge (mathematically speaking) that no computer can check every single spot. It's like trying to find the lowest valley in a continent by walking every inch of it.

This paper introduces a new tool called Fulqrum (a name inspired by the Latin word for "fulcrum," or the pivot point of a lever) that acts like a super-smart, high-tech drone for exploring this mountain range. Here is how it works, broken down into simple concepts:

1. The Problem: The "Too Big to Fit" Puzzle

Traditionally, to find the lowest point, scientists use a method called Quantum Subspace Diagonalization (QSD).

The Old Way: Imagine you send a quantum computer (the drone) to take photos of a few specific spots in the fog. Then, you bring those photos back to a regular computer to build a map.
The Bottleneck: The problem is that as the quantum computer gets more powerful (more "qubits," or bits of quantum information), the number of photos explodes. The regular computer's memory gets overwhelmed trying to build the map. It's like trying to build a 3D model of the entire Earth using only a tiny toy box; the box just isn't big enough. Also, different tools existed for different types of mountains (molecules vs. magnetic spins), and they didn't talk to each other.

2. The Solution: Fulqrum's "Smart Sorting"

Fulqrum is a new software framework that changes how we organize and process these photos. It uses three main tricks:

A. The "Universal Translator" (Extended Alphabet)

Think of quantum systems as having two different languages: one for qubits (like tiny magnets) and one for fermions (like electrons in molecules).

Before: You needed a translator for magnets and a different translator for electrons.
Fulqrum: It invented a "Universal Translator" (an extended alphabet). It translates everything into a single, unified language that includes special symbols for "projecting" (checking if something is there) and "laddering" (moving up or down energy levels). Now, the same tool can solve problems for both magnets and molecules without needing to switch gears.

B. The "Smart Filing Cabinet" (Bit-Sets and Hash Maps)

When the drone takes photos, it gets millions of "bit-strings" (sequences of 1s and 0s).

The Old Way: Storing these was like trying to fit a library of books into a shoebox. You had to use standard integer numbers, which capped the size of the library at about 128 books.
Fulqrum: It uses Bit-Sets. Imagine instead of writing the number "101" on a piece of paper, you just flip a switch on a massive wall of light switches. This is incredibly compact.
The Hash Map: To find a specific photo quickly, Fulqrum uses a Hash Map. Think of this as a super-organized library where every book has a unique barcode. Instead of walking down every aisle to find a book, the librarian (the computer) scans the barcode and knows exactly which shelf to go to instantly. This allows Fulqrum to handle mountains of data that would crash other programs.

C. The "Lazy Worker" (Grouping and Skipping)

This is the most clever part.

The Old Way: To build the map, the computer tried to calculate the connection between every photo and every other photo. It was doing a lot of math for connections that turned out to be zero (nothing happened).
Fulqrum: It groups the photos by their "shape" (mathematically, their off-diagonal structure). It realizes, "Hey, these 1,000 photos all behave the same way." It calculates the result once for the whole group and skips the rest.
The Analogy: Imagine you are painting a wall. The old way was to paint every single brick individually, even the ones that are already white. Fulqrum looks at a section, sees they are all white, and says, "Skip this whole section, it's already done." This saves a massive amount of time and energy.

3. The Results: Faster and Lighter

The authors tested Fulqrum on two types of problems:

Magnetic Chains: Simulating a line of interacting magnets.
Molecules: Simulating Nitrogen gas ( $N_2$ ) and a Methane dimer ( $CH_4$ ).

The Outcome:

Speed: Fulqrum was up to 10 times faster than existing tools.
Memory: It used up to 130 times less memory.
Scalability: While other tools broke down at 128 qubits, Fulqrum can theoretically handle thousands, limited only by the hardware, not the software.

4. The "Matrix-Free" Option

Sometimes, even with smart sorting, the map is still too big to build. Fulqrum has a "Matrix-Free" mode.

The Analogy: Instead of drawing the whole map on paper (which takes up space), Fulqrum acts like a GPS. When the computer asks, "What is the elevation at point X?", Fulqrum calculates the answer on the fly and gives it to you, then forgets it. It doesn't store the whole map, saving huge amounts of memory, though it takes a tiny bit more time to calculate each answer.

Summary

Fulqrum is a flexible, super-efficient software framework that allows scientists to solve complex quantum problems on classical computers by:

Speaking a universal language for all quantum systems.
Organizing data in a way that fits massive amounts of information into small spaces.
Skipping unnecessary calculations by grouping similar tasks.

It's like upgrading from a hand-drawn map to a high-speed, AI-driven GPS that can navigate the entire quantum universe without running out of gas (memory) or getting lost (time). This brings us one step closer to using quantum computers to solve real-world problems like designing new medicines or clean energy materials.

1. Problem Statement

Quantum Subspace Diagonalization (QSD) is a leading approach for solving eigenvalue problems (finding ground states and excited states) on near-term and fault-tolerant quantum computers. In QSD, a subspace is defined by bit-strings sampled from a quantum processor, and the Hamiltonian is diagonalized classically within this subspace.

However, existing QSD implementations face three critical limitations:

Lack of Unification: Current tools are domain-specific. Quantum chemistry packages (e.g., for fermionic systems) cannot easily handle qubit Hamiltonians, and vice versa, often requiring separate workflows and data formats.
Scalability Limits: Many existing solvers are restricted to $\le 128$ qubits due to reliance on standard integer data types for bit-string representation, which fails as quantum hardware scales beyond this threshold.
Performance Bottlenecks: Converting Hamiltonian operators and bit-string subspaces into data structures compatible with efficient Sparse Matrix-Vector Multiplication (SpMV) is computationally expensive. Existing methods often suffer from high memory consumption and slow runtime when scaling to large subspaces.

2. Methodology: The Fulqrum Framework

The authors introduce Fulqrum, a generalized, high-performance framework designed to unify qubit and fermionic QSD. The core methodology involves three primary components:

A. Extended Operator Alphabet and Unified Representation

Instead of decomposing all operators into standard Pauli strings ( $X, Y, Z, I$ ), Fulqrum utilizes an extended alphabet including projection operators ( $\hat{0}, \hat{1}$ ) and ladder operators ( $\hat{a}^-, \hat{a}^+$ ).

Fermionic-to-Qubit Mapping: Fermionic Hamiltonians are transformed into qubit Hamiltonians using an Extended Jordan-Wigner (JW) transformation. Unlike standard JW, which decomposes ladder operators into long Pauli strings, this method maps them directly to projection/ladder operators.
Operator Grouping: Terms in the Hamiltonian are sorted and grouped based on their off-diagonal structure (the set of indices where non-identity operators act).
- Terms sharing the same off-diagonal structure are grouped together.
- For fermionic systems, groups are further sorted by a "ladder integer" derived from the binary representation of ladder operators.
- Benefit: This allows the framework to evaluate matrix elements only for non-zero terms. If a group's ladder integer does not match the row bit-string, the entire group is skipped, drastically reducing the number of evaluations.

B. Subspace Data Structures

To handle bit-strings without integer limits:

Bit-Sets: Subspaces are stored as collections of boost::dynamic_bitset objects rather than integers. This removes the 128-qubit limit, allowing for arbitrary system sizes.
Hash Map Optimization: The subspace is stored in a custom emhash8::HashMap.
- Parallel Access: Unlike standard C++ hash maps, this structure allows parallel iteration over keys (bit-sets) using OpenMP.
- Bucket Occupancy Bit-Set: A custom optimization uses a bit-set to track bucket occupancy. This allows the algorithm to quickly reject empty buckets during lookups, significantly improving cache hit rates and search speed.

C. Matrix Evaluation and SpMV

Fulqrum generates sparse matrix representations (CSR format) or supports matrix-free SpMV:

Grouped Evaluation: Matrix elements are computed group-by-group. For a given row bit-string, the framework calculates the potential column bit-string. If the column exists in the subspace, the matrix element is computed; otherwise, it is zero.
Lower/Upper Triangle Optimization: By sorting bit-strings by integer value and inspecting the Most Significant Off-Diagonal Bit (MSOB), the framework can determine if a matrix element lies in the lower or upper triangle without explicitly computing the column bit-string first. This halves the number of required evaluations.
Fast CSR Construction: A "fast" mode constructs a temporary CSR-like structure in a single pass using dynamic vectors, which is then converted to a standard CSR matrix. This trades a small amount of memory for a significant speedup in construction time.
RAMPS (Recursive Algorithm for Minimal Perturbative Subspaces): A pre-processing step that prunes the subspace. It recursively adds only those bit-strings that perturbatively shift the target energy beyond a user-defined tolerance, removing "superfluous" bit-strings that do not impact the final eigenenergy.

3. Key Contributions

Unified Framework: A single codebase handles both qubit and fermionic systems by leveraging the extended operator alphabet and JW transformation, eliminating the need for separate solvers.
Unlimited Qubit Scalability: By using bit-sets instead of integers, the framework supports systems with far more than 128 qubits, addressing a critical bottleneck for future quantum advantage applications.
Performance Optimization:
- Grouping & Sorting: Reduces the number of matrix element evaluations by orders of magnitude by skipping zero-contributing groups.
- Memory Efficiency: Optimized hash maps and bit-set storage reduce memory overhead.
- Parallelism: Extensive use of OpenMP for parallelizing bit-string processing and matrix construction.
Flexibility: The framework does not perform eigensolving itself but generates data structures compatible with a wide range of classical solvers (ARPACK, PRIMME, SLEPc, CuPy), allowing users to choose the best solver for their specific problem.

4. Results

The authors benchmarked Fulqrum against existing tools (qiskit-addon-sqd for qubits and Dice for fermions) on two computing platforms.

Qubit Systems (Heisenberg Spin Chain):
- Runtime: Fulqrum was >10x faster than qiskit-addon-sqd for projecting Hamiltonians into the subspace.
- Scaling: As the number of qubits and bit-strings increased, the performance gap widened significantly.
- Memory: Fulqrum required significantly less peak memory, enabling the solution of larger problem instances on fixed hardware.
Fermionic Systems (N2 and CH4 Dimers):
- Runtime: Fulqrum was 34% faster (N2) and 9% faster (CH4) than Dice when building CSR matrices in the full subspace.
- Memory: Fulqrum reduced peak memory usage by ~2x (N2) and ~5x (CH4) compared to Dice.
- RAMPS Impact: Using the RAMPS pruning algorithm, Fulqrum reduced the subspace dimensionality by 40x (N2) and 39,000x (CH4). This resulted in memory reductions of up to 130x compared to Dice.
- Matrix-Free Mode: While slower in runtime, the matrix-free mode reduced memory consumption by ~94x (N2) and ~172x compared to CSR methods, making full subspace calculations feasible on personal laptops.

5. Significance

This work provides a critical infrastructure layer for Quantum Advantage.

Bridging the Gap: It enables the practical execution of QSD on near-term hardware by efficiently managing the classical post-processing of quantum samples, which is often the bottleneck.
Scalability: By removing the 128-qubit limit, it prepares the classical software stack for the next generation of quantum hardware.
Accessibility: The framework is open-source, written in C++/Python, and easily installable, lowering the barrier to entry for researchers compared to complex, domain-specific tools like Dice.
Future Outlook: The authors suggest that while the current version is highly performant, further gains can be made via MPI support and C++ refactoring. The framework serves as a flexible interface to test whether QSD applications can deliver viable quantum advantage in condensed matter physics and quantum chemistry.