Computing eigenpairs of quantum many-body systems with Polfed.jl

arXiv:2605.10191 · cond-mat.stat-mech, cond-mat.dis-nn, cond-mat.str-el, quant-ph · Submitted 2026-05-11 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Condensed Matter. The day in condensed matter: materials, phases and the measurements under them.

Kai: We're looking at the paper: "Computing eigenpairs of quantum many-body systems with Polfed.jl".

Mira: Here's the gist of the paper. Computing eigenpairs of quantum many-body systems with Polfed.jl presents an open-source Julia package implementing the Polynomially Filtered Exact Diagonalization (POLFED) algorithm for computing mid-spectrum eigenvalues and eigenvectors of large sparse matrices, which is essential for studying non-equilibrium many-body physics Pruning redundant reasoning tokens The paper introduces Polfed.jl, an open-source Julia package that implements the POLFED algorithm for computing mid-spectrum eigenpairs and eigenvectors of quantum many-body Hamiltonians.

Kai: This method addresses the challenge posed by the exponential growth of Hilbert space dimension by using a polynomial spectral transformation evaluated on the fly within a Lanczos iteration, which preserves Hamiltonian sparsity and reduces memory costs compared to other diagonalization methods How the training signal is built The core of POLFED involves finding mid-spectrum eigenpairs through several key steps: 1.

Mira: Spectral bounds are computed by using a standard Lanczos iteration to find the extremal eigenvalues, which are then used to rescale the Hamiltonian into H˜ via Eq.

Kai: (31) 2.

Title and authors: Kai: So this paper is about computing eigenpairs for quantum many-body systems using something called Polfed.jl. It’s an open-source Julia package that implements an algorithm called POLFED for finding those mid-spectrum eigenvalues and eigenvectors of large sparse matrices.

Mira: That sounds like it tackles the problem where the Hilbert space gets too big to handle with standard exact diagonalization methods, which is what we usually have to do for these quantum systems.

Lev: Right, so the core idea here is using a polynomial spectral transformation on the fly inside a Lanczos iteration to find those mid-spectrum pairs while keeping everything sparse and low memory.

Kai: Exactly. The paper describes how they find those mid-spectrum pairs through several steps, starting with finding the extremal eigenvalues using a standard Lanczos iteration to rescale the Hamiltonian into this H tilde via an equation on page thirty-one of THIS PAPER > <ref:2605.10191#pg1>

Mira: And then they use something like the kernel polynomial method to estimate the density of states near a target energy, which lets them determine a polynomial order K for their expansion.

Kai: That order K is found by setting up this requirement that the transformed eigenvalues at the edges of a spectral window should equal some cutoff value Omega, and they solve that using bisection search >

Lev: Then they run a block Lanczos iteration with on-the-fly filtering using something called the Clenshaw recurrence to evaluate P K lambda tilde H tilde V k without actually forming the matrix, which keeps it sparse >

Kai: The main thing they claim is that this avoids needing to factorize the sparse matrix entirely, unlike shift and invert methods that need a sparse LU factorization which brings in fill-in >

Mira: And because POLFED mostly relies on repeated sparse matrix vector or block matrix multiplications, it’s naturally suited for GPU acceleration because of its low memory footprint and good memory bandwidth usage >

Lev: The benchmarks show a big difference. they found that the cost of POLFED scales more mildly with connectivity than the factorization step in shift and invert methods, and on a single GPU, the wall time dropped from roughly two thousand minutes on sixteen CPUs down to about six minutes for an L value of twenty >

Kai: It’s also applied to models like the disordered XXZ chain and the quantum sun model, showing it works across different connectivity structures >

Mira: They also mention a few ways you can customize it, like using a function-based interface where you can provide a custom mapping function that does in place operations, which lets you separate diagonal and off-diagonal contributions for specific models >

Lev: And they have built in some optimizations too. the system can be set up to optimize mapping automatically, which builds routines to compress repeated off-diagonal values during the spectral transformation, and it can use a block size greater than one hundred for the block Lanczos factorization >

Kai: What I find interesting is that you can dynamically select target energies based on density of states estimates like maxdos or middle, allowing researchers to focus exactly on the spectral regions they care about >

Mira: And they provide detailed diagnostic reports that summarize all those spectral transformation parameters and the runtime breakdown, which helps people figure out exactly which computational step is costing them the most time when benchmarking different settings >

Kai: So what this means for us is that we can tackle much larger system sizes than before because of this on-the-fly filtering, and we’re getting good performance on hardware like GPUs because it stays sparse >

Mira: The paper's title, "Computing eigenpairs of quantum many-body systems with Polfed.jl", points to a method that efficiently handles the huge matrices that pop up in these interacting systems >

Lev: For us, Lev thinks this means we can push the limits of what we can diagonalize numerically for real hardware, especially when dealing with those large sparse Hamiltonians you have from condensed matter physics simulations >

Kai: So, to wrap up, the Polfed.jl package introduces an algorithm that computes mid-spectrum eigenpairs for large sparse matrices by using polynomial spectral filtering and on-the-fly operations that preserve sparsity >

Mira: This method offers significant gains over shift and invert approaches by avoiding sparse matrix factorization entirely and making it very friendly to GPU acceleration because the cost is dominated by sparse matrix operations >

Lev: The paper shows a substantial speedup on GPU, reducing wall time from two thousand minutes on CPUs down to about six minutes for L equal to twenty > <ref:2605.10191#pg3>

Kai: It's been applied successfully to models like the disordered XXZ chain and the quantum sun model, showing its robustness across different connectivity structures >

Mira: And they show you how you can tailor it with function-based interfaces and automatic optimizations, giving users more control over the spectral transformation process >

Lev: The main limitation they mention is that this method still relies on repeated sparse matrix multiplications, so if your system has extremely high connectivity or requires a very deep Krylov space, the overhead of those multiplications might become substantial >

Kai: So overall, this paper lays out a solid framework for finding those mid-spectrum states in complex quantum systems without getting bogged down in the memory explosion that usually stops us >

The paper's summary: Kai: So, to recap, Polfed is a Julia package that uses an algorithm called POLFED to find those mid-spectrum eigenpairs for quantum systems that have too many degrees of freedom for standard methods.

Mira: Yeah, it’s about using a polynomial transformation on the fly while running a Lanczos iteration. The big idea they’re pushing is keeping the Hamiltonian sparse while still getting these important mid-energy states.

Lev: From my side, what I like is that this avoids doing any matrix factorizations entirely, which you know is a huge headache for real hardware when you get to large systems.

Kai: That's right. They say that instead of those slow LU factorizations that cause fill-in, POLFED just uses sparse matrix vector products repeatedly. It keeps the memory footprint low and makes it way more suitable for getting this running on a GPU.

Mira: The theory behind it is building a polynomial spectral transformation based on how the density of states looks near your target energy. They figure out a polynomial order, let's call it K, by setting up a requirement that the transformed eigenvalues at the edges of your window have to match some cutoff value Omega.

Lev: So they use this bisection search just to nail down that order K before they start the actual iteration part. That sounds like a necessary step for ensuring you’re looking in the right place spectrally.

Kai: Exactly, and then when they run the block Lanczos iteration, they use something called the Clenshaw recurrence to evaluate that polynomial transformation without ever explicitly forming the big matrix. It’s all done on the fly.

Mira: And that dynamic filtering is what lets them tackle these much larger system sizes than before. They aren't limited by how many entries you can store in memory anymore because they aren't storing the whole matrix at once, just doing those necessary multiplications as they go.

Lev: Now, on real hardware, if the cost is dominated by repeated sparse matrix vector multiplications, that means you get good scaling with connectivity and a low memory bandwidth hit. It’s much more manageable than what you’d see if you had to do a full factorization step every time.

Kai: The benchmarks they show are pretty compelling too. They compare this against methods like shift and invert, and on a single GPU, the wall time dropped from two thousand minutes on sixteen CPUs down to about six minutes for a system size of twenty.

Mira: That reduction in wall time is significant for practical application. It means we can actually run these kinds of calculations faster than before on existing hardware setups.

Lev: But I do see a caveat, and this is important for me when thinking about real quantum error correction codes. The paper says the cost still comes from those repeated sparse matrix multiplications, so if you have extremely high connectivity or need a very deep Krylov space, that overhead of those multiplications could still be substantial.

Kai: So it’s not a magic bullet for every single kind of problem, but it’s a really solid framework for accessing mid-spectrum states in these complex models.

Mira: It definitely shifts the focus away from just finding the ground state or the lowest energy levels and toward characterizing those important intermediate spectral features.

Lev: So, if you were building a real hardware experiment right now, this suggests that focusing on methods that exploit sparsity and avoid explicit factorization is a much more realistic path for scaling up.

The paper's improvements: Tom: So we’re looking at how they plan to make Polfed even better, moving beyond just the basic implementation of mid-spectrum states for large matrices.

Kai: They’re adding a bunch of ways you can customize it, like using a function-based interface where you can provide your own mapping function. This lets users do in place operations, which is pretty cool because it lets you optimize things specific to your model, like separating the diagonal and off-diagonal parts of the Hamiltonian.

Mira: That’s useful because different models have different structures; some might benefit more from focusing on how those off-diagonal terms are handled during the spectral transformation.

Lev: And they’re putting in automatic optimization too, which I think is key for real hardware. If you turn that setting on, it builds routines to compress repeated off-diagonal values during the process, which cuts down on memory traffic and makes the whole thing run smoother.

Kai: That compression sounds like something that would be really valuable when we’re trying to map these theoretical results onto actual superconducting qubit architectures. We need to know what the memory access pattern looks like.

Mira: Exactly, because it ties back into the assumption that you can handle a certain amount of complexity because you’ve managed the transformation efficiently. It makes that memory management part much more transparent for the theorist.

Lev: They also suggested you can use a block size greater than one hundred for the block Lanczos iteration. That balances parallel efficiency with how deep your Krylov space needs to be to get convergence, which is a practical choice when you’re thinking about running this on a cluster.

Kai: A block size over one hundred, that tells me they think the required Krylov dimension might actually be quite large for some of these systems, so they are anticipating those deep searches.

Mira: And there’s this feature where you can dynamically select your target energies based on density of states estimates like maxdos or middle. This lets researchers focus exactly on the spectral region they care about most without having to sweep through everything blindly.

Lev: That ability to focus the search is smart, but I wonder how accurately those density of states estimates are working when you’re using this polynomial filter method instead of a direct diagonalization approach.

Kai: They provide detailed diagnostic reports too, summarizing all those transformation parameters and the runtime breakdown. That helps you figure out precisely which step—the polynomial order determination or the matrix multiplication itself—is actually dominating the cost for any given setup.

Mira: It’s good they are providing that level of detail, because when you’re trying to compare this against other methods, knowing exactly where the time is spent on every single calculation matters a lot.

Lev: So it’s less about getting one perfect number and more about understanding the entire cost landscape of the algorithm itself. It moves you from just getting an answer to understanding *how* you got that answer.

Conclusion: Kai: So we’re wrapping up "Computing eigenpairs of quantum many-body systems with Polfed.jl" by summarizing what this Julia package actually does for those large sparse matrices.

Mira: Basically, it shows how you can find those important mid-spectrum states without needing to build the whole matrix explicitly, by using this polynomial filtering technique on the fly.

Lev: And for real hardware running error correction simulations, that means avoiding explicit sparse matrix factorizations is a big win for keeping the computational overhead down.

Kai: It’s about making large systems accessible again because you aren't stuck with those memory explosion problems that usually stop us when we try to diagonalize them directly.

Mira: The main implication is that we can now explore much larger system sizes, and they show how this method scales mildly with connectivity compared to other methods like shift and invert.

Lev: That speedup on the GPU, reducing wall time from two thousand minutes down to about six minutes for a twenty-site system, shows that this approach has real practical potential right now.

Kai: It’s also applied successfully to complex models like the disordered XXZ chain and the quantum sun model, meaning it's not just theoretical fluff; it works on different kinds of physical systems.

Mira: The paper’s title, "Computing eigenpairs of quantum many-body systems with Polfed.jl," points toward a more flexible way for theorists to characterize the spectrum beyond just the ground state or lowest energy levels.

Lev: I just want to say that while it’s powerful, you still have to be careful about what kind of problem you throw at it; if your system has extremely high connectivity, those repeated sparse matrix multiplications are still going to take time.

Kai: That’s fair; the authors themselves flag that the cost is dominated by those multiplication steps, so it’s not a magic bullet for every single computational challenge we face in quantum hardware.

Mira: But overall, this work gives us a robust tool that lets us focus on those intermediate spectral features in complex many-body physics with much better memory efficiency than before.

Lev: It’s an interesting step forward for simulating these larger systems on real hardware because it addresses the memory constraints directly through algorithmic structure rather than just hoping for better hardware.

Rok Pintar, Konrad Pawlik, Rafał Swiłetek, Miroslav Hopjan, Jan š Šuntajs, Jakub Zakrzewski, Piotr Sierant, Lev Vidmar

Department of Physics, Faculty of Mathematics and Physics, University of Ljubljana · Department of Theoretical Physics, Jožef Stefan Institute · Szkoł Doktorska Nauk Scisłych i Przyrodniczych, Uniwersytet Jagiellołnski · Instytut Fizyki Teoretycznej, Wydział Fizyki, Astronomii i Informatyki Stosowanej, Uniwersytet Jagiellonski · Mark Kac Complex Systems Research Center · Institut für Theoretische Physik, Georg-August-Universität Göttingen · Institute of Theoretical Physics, Faculty of Fundamental Problems of Technology, Wrocław University of Science and Technology · Barcelona Supercomputing Center

cond-mat.stat-mech, cond-mat.dis-nn, cond-mat.str-el, quant-ph

Submitted: 2026-05-11

Updated: 2026-11-01

Comments: Code is available at: https://github.com/RockClimbingRocks/Polfed.jl

Code: https://github.com/RockClimbingRocks/Polfed.jl

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 79/100

The gist: Computing eigenpairs of quantum many-body systems with Polfed.jl presents an open-source Julia package implementing the Polynomially Filtered Exact Diagonalization (POLFED) algorithm for computing…

Key concepts

POLFED Algorithm
A method for finding middle eigenvalues in large sparse matrices by using a polynomial filter on the fly during a Lanczos iteration. It transforms the Hamiltonian to make target eigenvalues easier to find while keeping matrix sparsity intact.
Spectral Bounds and Rescaling
The process starts by finding the lowest and highest extremal eigenvalues using standard Lanczos. These bounds are then used to rescale the original Hamiltonian into a new form (H~). This rescaling simplifies the search for eigenvalues within a specific energy window.
On-the-fly Filtering
Instead of forming large matrices, POLFED uses sparse matrix-vector products and the Clenshaw recurrence to apply the polynomial filter directly during the block Lanczos iteration. This keeps memory usage low by avoiding explicit matrix construction.

Terminology

Summary

Computing eigenpairs of quantum many-body systems with Polfed. p. 0jl presents an open-source Julia package implementing the Polynomially Filtered Exact Diagonalization (POLFED) algorithm for computing mid-spectrum eigenvalues and eigenvectors of large sparse matrices, which is essential for studying non-equilibrium many-body physics

Pruning redundant reasoning tokens

The paper introduces Polfed.jl, an open-source Julia package that implements the POLFED algorithm for computing mid-spectrum eigenpairs and eigenvectors of quantum many-body Hamiltonians. p. 0 This method addresses the challenge posed by the exponential growth of Hilbert space dimension by using a polynomial spectral transformation evaluated on the fly within a Lanczos iteration, which preserves Hamiltonian sparsity and reduces memory costs compared to other diagonalization methods

How the training signal is built

The core of POLFED involves finding mid-spectrum eigenpairs through several key steps:

  1. Spectral bounds are computed by using a standard Lanczos iteration to find the extremal eigenvalues, which are then used to rescale the Hamiltonian into H˜ via Eq. p. 6 (31)

  2. The density of states is estimated near the target energy using methods like the kernel polynomial method (KPM) to determine the polynomial order K

  3. The polynomial order K is determined by requiring that transformed eigenvalues at the edges of a spectral window equal a cutoff value Ω, solved via bisection search

  4. The block Lanczos iteration is performed with on-the-fly filtering using the Clenshaw recurrence to evaluate P Kλ˜(H˜)V k without explicitly forming the matrix, which preserves sparsity

Where the gains come from

The advantages of POLFED over alternative methods like shift-and-invert are significant, as it avoids sparse matrix factorization entirely. Specifically, POLFED applies the polynomial filter on the fly using only sparse matrix-vector products, which preserves sparsity and drastically reduces memory requirements compared to shift-and-invert methods that require a sparse LU factorization leading to fill-in Furthermore, the algorithmic structure of POLFED is dominated by repeated sparse matrix–block multiplications, making it naturally suited for GPU acceleration due to its low memory footprint and suitability for high memory bandwidth operations

Benchmarking and practical application

The paper provides comprehensive benchmarks comparing POLFED against shift-and-invert methods on CPU and GPU architectures. The results demonstrate that POLFED offers favorable computational scaling, as its cost is dominated by repeated sparse matrix–vector or sparse matrix–matrix multiplications, which grows more mildly with connectivity than the factorization step in shift-and-invert GPU implementations show substantial speedups, with the total wall time reduced from roughly 2000 minutes on 16 CPU cores to approximately 6 minutes on a single GPU for L = 20 The package has been successfully applied to various models, including the disordered XXZ chain and the quantum sun model, demonstrating its robustness across different connectivity structures The authors also provide code for constructing the quantum sun model Hamiltonian

Interface and optimization

Polfed.jl is designed to be flexible, supporting both a matrix-based interface and a function-based interface where users can provide a custom mapping function f! p. 9

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

  1. Polynomial spectral filtering on fly allows computation of mid-spectrum eigenvalues for large sparse matrices while preserving Hamiltonian sparsity, which enables access to larger system sizes than alternative diagonalization methods.

  2. GPU acceleration is natively supported because the dominant computational cost reduces to repeated sparse matrix-vector multiplications, leveraging the hardware's high memory bandwidth and arithmetic throughput effectively.

  3. The interface supports function-based mapping where users can provide a custom mapping function that performs in place operations, allowing for model-specific optimizations like separating diagonal and off-diagonal contributions.

  4. The system can be optimized automatically by setting optimize mapping=true, which builds specialized routines to compress repeated off-diagonal values and reduce memory traffic during the spectral transformation.

  5. The system can perform block Lanczos factorization using a block size greater than 100, balancing parallel efficiency with convergence requirements, as suggested by the estimate for required Krylov dimension.

  6. The system can dynamically select target energies based on density of states estimates like :maxdos or :middle, allowing researchers to focus on specific spectral regions of interest.

  7. The system can provide detailed diagnostic reports that summarize the spectral transformation parameters and runtime breakdown, helping users identify which computational step dominates the cost for benchmarking different settings.

Sources

Related papers