BosonFlow: A C++ codebase for dynamic fRG and single-boson exchange in correlated fermion systems

The paper introduces BosonFlow, a unified C++ codebase that implements dynamic functional renormalization group and parquet equations within the single-boson exchange formalism to compute full dynamic vertices and self-energies for correlated fermion systems using a truncated unity framework.

The Gist

The Big Picture: Solving the "Too Many Variables" Puzzle

Imagine you are trying to predict the weather in a massive, chaotic city. You have millions of people (electrons) moving around, interacting, and influencing each other. Sometimes they form a crowd (magnetism), sometimes they dance in pairs (superconductivity), and sometimes they just scatter randomly.

To understand this city, physicists use a powerful mathematical tool called the Functional Renormalization Group (fRG). Think of fRG as a "slow-motion camera" that starts by looking at the city from a distance (where everything looks simple) and slowly zooms in, step-by-step, to see how individual interactions create complex patterns.

The Problem:
For a long time, scientists had to make a terrible choice, like a photographer with a broken camera:

1. Option A: Focus on where people are (momentum) but blur out when they interact (frequency). This misses the timing of events, leading to wrong predictions about when things change (like when a material becomes a superconductor).
2. Option B: Focus on when they interact but blur out where they are. This works for single atoms but fails for big crystals where location matters.

The Solution:
BosonFlow is a new, super-smart software tool (written in C++) that finally lets the camera focus on both location and time simultaneously. It does this by using a clever trick called Single-Boson Exchange (SBE).

---

The Core Trick: The "Messenger" Analogy

In the old way of doing things, the software tried to track every single electron talking to every other electron directly. It's like trying to listen to every conversation in a stadium at once. It's impossible.

BosonFlow changes the game by realizing that electrons don't usually talk directly. Instead, they send messengers.

• The Old Way: Electron A yells at Electron B. (Hard to track).
• The BosonFlow Way: Electron A throws a ball (a "boson") to Electron B. Electron B catches it.

The software realizes that instead of tracking the complex 4-way conversation between four electrons, it only needs to track:

1. The Ball (the boson propagator).
2. The Thrower (the electron-boson vertex).
3. The Catcher.

This simplifies the math massively. It's like realizing you don't need to know the entire history of a phone call to understand the signal; you just need to know the signal strength and the frequency.

How the Code Works (The "Construction Site")

The paper describes BosonFlow not just as a calculator, but as a highly organized construction site.

• The Blueprint (The Model): The code is built so you can swap out the "city" you are studying. You can tell it, "Build a square grid city" (like the Hubbard model for high-temperature superconductors) or "Build a single isolated house" (an impurity model). The code automatically adjusts its internal maps to fit the new city without breaking.
• The Flow Schemes (The Zoom Levels): The software can zoom in at different speeds.
  • Frequency Flow: Zooms in by changing the temperature.
  • Interaction Flow: Zooms in by turning up the volume of the interactions.
  • Multi-loop: This is the "super-zoom." It checks its own work. If the first pass missed a detail, it loops back, corrects the error, and refines the picture. This ensures the results are physically accurate and don't contain "ghosts" (artifacts that look real but aren't).
• The Output (The Report): When the calculation is done, it doesn't just give you a number. It spits out a massive, organized database (HDF5 files) containing the "weather map" of the electrons. You can look at how the "magnetic storms" or "superconducting dances" form across the city.

Why This Matters

Before BosonFlow, scientists had to guess. They had to ignore the timing of electron interactions, which led to wrong predictions about critical temperatures (e.g., "This material becomes a superconductor at 100K!" when it actually happens at 10K).

BosonFlow fixes this by:

1. Keeping the Timing: It respects the "frequency" (time) of interactions, which is crucial for understanding real-world materials.
2. Handling Complexity: It can handle materials with "electron-phonon" coupling (where electrons interact with the vibrations of the crystal lattice, like a dancer interacting with the floor).
3. Being Open and Flexible: It's open-source. If a researcher wants to study a new type of material, they don't have to rewrite the whole engine; they just plug in a new "blueprint" (model), and the engine runs.

The "Secret Sauce" Analogy: The Truncated Unity

The paper mentions a "Truncated Unity" framework. Imagine you are trying to describe a complex painting.

• The Old Way: You try to describe every single pixel. (Too much data).
• BosonFlow: You realize the painting is made of a few basic brushstrokes (squares, circles, lines). You describe the painting by saying, "It's 80% circles, 15% lines, and 5% squares."
  This "Truncated Unity" approach compresses the massive amount of data about where electrons are into a few key "shapes" (form factors), making the calculation fast enough to run on modern computers without losing accuracy.

Summary

BosonFlow is a state-of-the-art digital laboratory. It allows physicists to simulate how electrons behave in complex materials with a level of detail that was previously impossible. By treating electrons as messengers throwing balls (bosons) rather than shouting directly at each other, and by using smart compression techniques, it solves the "too many variables" problem.

It is the tool that helps us understand why some materials conduct electricity with zero resistance, why others become magnets, and how we might design the supercomputers and energy grids of the future.

Technical Summary

1. Problem Statement

The study of strongly correlated electron systems (e.g., high-temperature superconductors) requires theoretical methods capable of handling competing orders (magnetic, charge-density-wave, superconducting) in a diagrammatically unbiased way.

• The Challenge: The functional Renormalization Group (fRG) and parquet equations are powerful tools for this, but their numerical implementation is hindered by the high dimensionality of the two-particle vertex, which depends on three independent momentum and frequency arguments.
• The Trade-off: Existing open-source tools force a computational trade-off:
  • Static approximations: Neglecting frequency dependence to achieve high momentum resolution (e.g., divERGe). This fails to capture quasi-particle lifetimes and often leads to unphysical overestimation of critical temperatures.
  • Impurity models: Resolving full dynamics but neglecting momentum dependence for lattice systems (e.g., KeldyshQFT).
  • Existing Lattice Solvers: Tools like TUPS use parquet decompositions but often lack the specific dynamic vertex structures needed for quantitative accuracy in lattice models, while DiFfRG targets high-energy physics without Fermi surfaces.
• The Gap: There is a lack of a unified, open-source C++ framework that simultaneously resolves full dynamic vertex structures (frequency and momentum dependence) for lattice models using a computationally efficient formalism.

2. Methodology

The paper introduces BosonFlow, a C++ codebase designed to solve the functional renormalization group equations for lattice models using the Single-Boson Exchange (SBE) formalism.

Core Theoretical Framework

• Single-Boson Exchange (SBE) Decomposition: Instead of treating the full two-particle vertex $V(k_1, k_2, k_3)$ directly, BosonFlow decomposes it into simpler objects:
  • Bosonic propagators ($w_r$): Representing collective modes.
  • Fermion-boson vertices ($\lambda_r$): Hedin vertices.
  • Multiboson rest functions ($M_r$): Remaining contributions.
  • Irreducible vertex ($I_{2PI}$): Set to the bare interaction $U$ in conventional schemes.
• Physical Channels: The decomposition is mapped onto physical channels (Magnetic, Density, Superconducting) to exploit SU(2) spin symmetry, reducing the number of independent components.
• Truncated Unity (TU) Framework: Momentum dependence is handled via a truncated unity expansion. Fermionic momentum dependence is projected onto a compact basis of form factors (e.g., s-wave, p-wave, d-wave), while bosonic transfer momenta are discretized on a Brillouin-zone grid. This drastically reduces the memory and computational cost compared to full grid representations.
• Flow Schemes: The code supports:
  • One-loop and Multiloop fRG: Multiloop extensions remove unphysical regulator dependence and satisfy the Mermin-Wagner theorem (preventing artificial long-range order in 2D).
  • Cutoff Schemes: Frequency ($\Omega$-flow), Temperature, and Interaction ($U$-flow) cutoffs.
  • G+U Flow: A scheme where both propagators and bare interactions are dressed with regulators, enabling efficient temperature scans for electron-phonon systems.
  • DMF2RG: Interpolating flow starting from Dynamical Mean-Field Theory (DMFT) results.

Software Architecture

• Language: C++20.
• Design Principle: Separation of Concerns (SoC). The code is modular, separating:
  1. Model: Lattice geometry, dispersion, and bare interactions.
  2. Flow Scheme: Regulators and propagator definitions.
  3. Solver/RHS: Ordinary Differential Equation (ODE) integration or fixed-point iteration.
  4. State: Storage of self-energies and SBE objects.
• Template Metaprogramming: The entire codebase is templated on the Model type, allowing compile-time selection of lattice geometry and parameters without runtime overhead.
• Parallelization: Utilizes OpenMP for multi-threaded parallelization and FFTW3 for bubble convolutions.
• I/O: Results are stored in HDF5 format, facilitating post-processing in Python, MATLAB, or Julia.

3. Key Contributions

1. Unified Dynamic Solver: BosonFlow is the first open-source tool to combine full dynamic vertex resolution (frequency and momentum) with lattice models using the SBE formalism.
2. Multiloop SBE Implementation: It implements multiloop fRG equations within the SBE framework, ensuring quantitative accuracy and consistency with parquet approximations at loop convergence.
3. Generalized SBE for Non-Local Interactions: The code incorporates the B+F splitting (Bosonic + Fermionic parts of the bare interaction), allowing the SBE formalism to be applied to models with retarded interactions (e.g., electron-phonon coupling) and non-local Coulomb interactions.
4. Flexible Architecture: The modular design allows users to easily:
   • Add new lattice models (e.g., Triangular, FCC, 1D chains).
   • Implement new cutoff schemes (e.g., temperature flow for Holstein models).
   • Switch between ODE solvers and self-consistent fixed-point iterations.
5. Benchmarking and Diagnostics: The code includes tools for fluctuation diagnostics, self-energy flow equations (via Schwinger-Dyson equations), and detailed output of vertex components.

4. Results and Applications

The paper demonstrates the code's capabilities through several applications:

• 2D Square-Lattice Hubbard Model:
  • One-loop fRG: Confirmed that near the pseudo-critical transition, only the magnetic bosonic propagator diverges, while other objects remain finite. This validates the efficiency of the SBE approximation.
  • Multiloop fRG: Successfully reproduced parquet approximation results at loop convergence. The multiloop approach cured the artificial long-range order found in one-loop approximations, consistent with the Mermin-Wagner theorem.
  • Pseudogap Analysis: Used to study the opening of the pseudogap in the square-lattice Hubbard model, analyzing form-factor truncations.
• Extended Models:
  • Hubbard-Holstein & Anderson-Holstein: Successfully applied the G+U flow scheme to systems with electron-phonon coupling, enabling temperature flows for retarded interactions.
  • Extended Hubbard Models: Applied to models with screened Coulomb interactions.
• Impurity Models: Benchmarked against the Anderson impurity model and the Anderson-Holstein model.

5. Significance

• Quantitative Accuracy: By resolving the full frequency dependence, BosonFlow avoids the qualitative errors associated with static approximations (e.g., incorrect critical temperatures, missing pseudogap physics).
• Methodological Reference: It serves as a reference implementation for the SBE formulation of fRG, clarifying the relationship between multiloop fRG, parquet equations, and SBE decompositions.
• Community Resource: As an open-source C++ codebase, it lowers the barrier to entry for researchers wishing to perform high-precision many-body calculations on correlated electron systems. It provides a flexible foundation for developing new approximations, such as those involving intermediate representations (IR) or discrete Lehmann representations (DLR).
• Bridging Scales: It bridges the gap between impurity solvers (which handle dynamics well) and lattice solvers (which handle momentum well), offering a unified approach for both.

In summary, BosonFlow represents a significant advancement in computational condensed matter physics, providing a robust, flexible, and accurate tool for studying the dynamic properties of strongly correlated fermion systems on lattices.