pith. sign in

arxiv: 2505.02901 · v3 · submitted 2025-05-05 · ❄️ cond-mat.str-el · physics.comp-ph

XDiag: Exact Diagonalization for Quantum Many-Body Systems

Alexander Wietek , Luke Staszewski , Martin Ulaga , Paul L. Ebert , Hannes Karlsson , Siddhartha Sarkar , Leyna Shackleton , Aritra Sinha
show 1 more author
Rafael D. Soares
This is my paper

Pith reviewed 2026-05-22 16:46 UTC · model grok-4.3

classification ❄️ cond-mat.str-el physics.comp-ph
keywords exact diagonalizationquantum many-body systemsopen-source softwaresymmetry-adapted basesdistributed parallelizationsublattice codingspin modelsJulia interface
0
0 comments X

The pith

XDiag combines C++ efficiency with Julia usability for symmetry-aware exact diagonalization of large quantum many-body systems.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper introduces XDiag as an open-source package that brings advanced exact diagonalization techniques to researchers working on quantum spins and electrons. It implements sublattice coding to handle large spin systems, Lin tables for fast symmetry lookups, and random hashing to distribute work across many processors, all wrapped in an accessible Julia interface on top of a fast C++ core. A sympathetic reader would value this because exact diagonalization gives numerically exact answers for ground states, spectra, and dynamics in models where approximate methods are hard to trust. The package includes automated symmetry handling, support for multiple Hilbert space types, and extensive examples to lower the barrier for performing these calculations. This matters for benchmarking other techniques and exploring phenomena in strongly correlated systems that fit within reachable system sizes.

Core claim

XDiag is an open-source software package implemented in C++ and wrapped in Julia that provides the first public implementation of sublattice coding for large-scale spin diagonalizations, efficient Lin table algorithms for symmetry lookups, and random-hashing techniques for distributed-memory parallelization, enabling symmetry-adapted exact diagonalization calculations for spin, electron, and t-J models with near-linear scaling on thousands of CPU cores.

What carries the argument

The XDiag library core, which uses sublattice coding to construct symmetry-adapted bases for spin systems, Lin tables for rapid symmetry lookups, and random hashing to enable distributed parallelization across processors.

If this is right

  • Researchers gain the ability to diagonalize larger spin systems than with prior public tools due to symmetry reduction and distributed scaling.
  • Automated symmetry block calculations become routine for spin-1/2, electron, and t-J models.
  • Near-linear scaling on thousands of cores enables previously inaccessible system sizes in ground-state and dynamical studies.
  • Reproducible examples and documentation support immediate use for spectral functions, time evolution, and thermal states.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The tool could serve as a reference standard for validating approximate methods such as tensor networks on intermediate lattice sizes.
  • Community extensions might add support for bosonic or mixed Hilbert spaces not currently emphasized.
  • Integration with Julia's ecosystem could enable hybrid workflows combining exact diagonalization with machine-learning post-processing of spectra.

Load-bearing premise

The C++ implementations of sublattice coding, Lin tables, and random hashing are correct and achieve the claimed near-linear scaling when accessed via the Julia interface.

What would settle it

A timing benchmark on a large spin system that shows computation time failing to decrease proportionally when scaling from hundreds to thousands of CPU cores would disprove the parallelization performance.

read the original abstract

Exact diagonalization (ED) is a cornerstone technique in quantum many-body physics, enabling precise solutions to the Schr\"odinger equation for interacting quantum systems. Despite its utility in studying ground states, excited states, and dynamical behaviors, the exponential growth of the Hilbert space with system size presents significant computational challenges. We introduce XDiag, an open-source software package designed to combine advanced and efficient algorithms for ED with and without symmetry-adapted bases with user-friendly interfaces. Implemented in C++ for computational efficiency and wrapped in Julia for ease of use, XDiag provides a comprehensive toolkit for ED calculations. Key features of XDiag include the first publicly accessible implementation of sublattice coding algorithms for large-scale spin system diagonalizations, efficient Lin table algorithms for symmetry lookups, and random-hashing techniques for distributed memory parallelization. The library supports various Hilbert space types (e.g., spin-1/2, electron, and t-J models), facilitates symmetry-adapted block calculations, and automates symmetry considerations. The package is complemented by extensive documentation, a user guide, reproducible benchmarks demonstrating near-linear scaling on thousands of CPU cores, and over 20 examples covering ground-state calculations, spectral functions, time evolution, and thermal states. By integrating high-performance computing with accessible scripting capabilities, XDiag allows researchers to perform state-of-the-art ED simulations and explore quantum many-body phenomena with unprecedented flexibility and efficiency.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

3 major / 2 minor

Summary. The manuscript introduces XDiag, an open-source C++ library with Julia wrappers for exact diagonalization of quantum many-body systems. It implements sublattice coding for large-scale spin ED, Lin-table algorithms for symmetry lookups, and random-hashing techniques for distributed-memory parallelization. The package supports spin-1/2, electron, and t-J models with automated symmetry-adapted block calculations. The authors provide extensive documentation, over 20 examples covering ground states, spectral functions, time evolution, and thermal states, plus reproducible benchmarks that demonstrate near-linear scaling on thousands of CPU cores.

Significance. If the C++ implementations are verified to be correct and the reported scaling holds without significant Julia overhead, XDiag would represent a useful addition to the field by releasing the first public sublattice-coding implementation for spin systems together with efficient symmetry tools and parallelization. The combination of high-performance core, user-friendly Julia interface, reproducible benchmarks, and broad set of examples could facilitate larger-scale ED studies in quantum many-body physics.

major comments (3)
  1. [Abstract] Abstract: the claim that the implementations 'achieve near-linear scaling on thousands of CPU cores' is presented without reference to specific benchmark data, scaling plots, error bars, or comparisons against independent reference codes; this performance assertion is load-bearing for the central contribution and requires explicit quantitative support in the benchmarks section.
  2. [Implementation] Implementation section (sublattice coding and random-hashing paragraphs): the manuscript provides no pseudocode, key algorithmic equations, or validation tests (e.g., exact reproduction of known small-system spectra or basis-size checks) for the C++ core; without such details the correctness of basis construction, hash collision handling, and symmetry block partitioning cannot be independently assessed.
  3. [Benchmarks] Benchmarks section: no data isolating Julia wrapper overhead versus native C++ performance is shown, nor are strong-scaling plots provided for system sizes beyond the reported examples; this leaves open whether the headline near-linear scaling on thousands of cores survives when the library is used through the advertised Julia interface.
minor comments (2)
  1. [Introduction] The manuscript would benefit from a concise comparison table (e.g., Table X) listing XDiag features against existing packages such as QuSpin, ALPS, or HPhi to clarify the precise novelty of the sublattice-coding and Lin-table components.
  2. [Documentation] Ensure that all acronyms (ED, Lin table, t-J model) are defined at first use and that the user guide contains explicit installation commands for common HPC environments.

Simulated Author's Rebuttal

3 responses · 0 unresolved

We thank the referee for their careful reading of the manuscript and for the constructive comments, which have helped us identify areas for improvement. We address each major comment below and have revised the manuscript accordingly to strengthen the presentation of our results and implementation details.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the claim that the implementations 'achieve near-linear scaling on thousands of CPU cores' is presented without reference to specific benchmark data, scaling plots, error bars, or comparisons against independent reference codes; this performance assertion is load-bearing for the central contribution and requires explicit quantitative support in the benchmarks section.

    Authors: We agree that the abstract should provide explicit pointers to the supporting data. The benchmarks section already contains scaling plots and quantitative results for system sizes up to several thousand sites on thousands of cores, including multiple runs for error estimation. We will revise the abstract to directly reference the relevant figures and tables in the benchmarks section, specifying the system sizes, core counts, and observed scaling behavior. revision: yes

  2. Referee: [Implementation] Implementation section (sublattice coding and random-hashing paragraphs): the manuscript provides no pseudocode, key algorithmic equations, or validation tests (e.g., exact reproduction of known small-system spectra or basis-size checks) for the C++ core; without such details the correctness of basis construction, hash collision handling, and symmetry block partitioning cannot be independently assessed.

    Authors: The primary contribution of the work is the open-source library, whose full source code (including the C++ implementation) is publicly available for inspection. However, we acknowledge that the manuscript would benefit from more self-contained details. We will add a dedicated subsection to the Implementation section containing pseudocode for the sublattice coding and random-hashing procedures, key equations for symmetry block partitioning, and explicit validation tests that reproduce known exact spectra and basis dimensions for small systems. revision: yes

  3. Referee: [Benchmarks] Benchmarks section: no data isolating Julia wrapper overhead versus native C++ performance is shown, nor are strong-scaling plots provided for system sizes beyond the reported examples; this leaves open whether the headline near-linear scaling on thousands of cores survives when the library is used through the advertised Julia interface.

    Authors: The reported benchmarks were performed through the Julia interface, which is the intended user workflow. To directly address the overhead question, we will add a new subsection with timing comparisons between equivalent calculations executed via the Julia wrappers and direct C++ calls. We will also extend the strong-scaling plots to additional system sizes beyond the current examples and include data confirming that near-linear scaling persists at larger scales when using the Julia interface. revision: yes

Circularity Check

0 steps flagged

No circularity: software library description with no derivation chain

full rationale

The paper introduces the XDiag software package and describes its algorithmic components (sublattice coding, Lin tables, random hashing) and performance benchmarks. No equations, physical predictions, or first-principles derivations are present that could reduce to self-definitions, fitted inputs renamed as predictions, or self-citation chains. Claims rest on implementation details and reproducible benchmarks rather than any load-bearing theoretical step that collapses to its own inputs by construction. This matches the default expectation for non-circular papers and the reader's assessment of score 0.0.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is a software-implementation paper. No free parameters are fitted to data, no mathematical axioms are invoked beyond standard linear algebra, and no new physical entities are postulated.

pith-pipeline@v0.9.0 · 5814 in / 1195 out tokens · 105670 ms · 2026-05-22T16:46:56.128076+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Forward citations

Cited by 7 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. CERTIFY-ED: A Multi-Layer Verification Framework for Exact Diagonalization of Quantum Many-Body Systems

    cond-mat.str-el 2026-05 accept novelty 7.0

    CERTIFY-ED supplies a multi-oracle eigensolver, thirteen independent validation layers, and tamper-evident certificates that detect errors and certify exact diagonalization outputs for quantum many-body models.

  2. Fluctuation-driven chiral ferromagnetism

    cond-mat.str-el 2026-05 unverdicted novelty 7.0

    Magnetization-non-conserving spin-orbit interactions enable quantum fluctuations to stabilize chiral ferromagnetic phases with spontaneous orbital chirality and enhanced thermal Hall effect, contrary to classical pred...

  3. Melting upon cooling in a quantum magnet

    cond-mat.str-el 2026-05 unverdicted novelty 7.0

    In the Ising-like triangular antiferromagnet Er7TaO12, long-range magnetic order forms on cooling then melts into short-range correlations at lower temperature, realizing a spin analog of the Pomeranchuk effect.

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

    cond-mat.stat-mech 2026-05 accept novelty 6.0

    Polfed.jl provides a GPU-accelerated Julia implementation of polynomially filtered exact diagonalization that accesses larger mid-spectrum eigenpairs of quantum many-body Hamiltonians than prior methods.

  5. A Generalized Coherent State Framework for Many-Body Density of States

    cond-mat.str-el 2026-04 unverdicted novelty 6.0

    A generalized coherent-state framework computes many-body density of states in irreducible sectors, supplies rigorous ground-state energy bounds, and identifies quantum and excited-state phase transitions in the LMG m...

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

    cond-mat.stat-mech 2026-05 conditional novelty 5.0

    Polfed.jl provides an efficient implementation of polynomially filtered Lanczos diagonalization for mid-spectrum eigenpairs in quantum many-body systems, supporting larger sizes via on-the-fly polynomial transformatio...

  7. Exact and mean-field analysis of the role of Hubbard interactions on flux driven circular current in a quantum ring

    cond-mat.mes-hall 2025-12 unverdicted novelty 4.0

    On-site repulsion monotonically suppresses current in ordered rings while extended interactions show filling-dependent enhancement or suppression, with disorder altering these trends at low fillings.