Accelerating Nonequilibrium Green functions simulations: the G1-G2 scheme and beyond

This paper presents an overview of the G1-G2 scheme, a time-local reformulation of the Kadanoff-Baym ansatz that reduces the computational scaling of Nonequilibrium Green functions simulations from cubic to linear, enabling high-level many-body calculations for diverse systems such as Hubbard clusters, graphene, and ion-matter interactions while discussing current limitations and future directions.

The Gist

Imagine you are trying to predict how a massive crowd of people (electrons) will move through a city after a sudden event, like a fire alarm or a concert starting. This is what physicists call a Nonequilibrium Green Function (NEGF) simulation. They want to know exactly where every person is, how they interact, and how they react to external forces (like lasers or ions) in real-time.

For decades, this was like trying to predict the movement of every single person in a stadium by asking every person what every other person they've ever met is doing. It's incredibly accurate, but the math is so heavy that the computer runs out of memory or takes years to finish the calculation. The problem was that the time it took to run the simulation grew cubically with time. If you wanted to simulate 10 seconds, it took $10^3$ (1,000) units of effort. If you wanted 100 seconds, it took $100^3$ (1,000,000) units. It was impossible to simulate long events.

This paper introduces a revolutionary new way to do these calculations, called the G1-G2 Scheme, and explains how to fix its remaining problems. Here is the breakdown in simple terms:

1. The Old Problem: The "Memory" Trap

Think of the old method as a historian trying to write a biography of a crowd. To know what a person is doing right now, the historian has to look back at every single interaction that person had since the beginning of time.

• The Cost: As time goes on, the historian has to carry an ever-growing stack of papers (memory) and read through them for every new second. The more time you simulate, the slower it gets, until it grinds to a halt.

2. The G1-G2 Solution: The "Local" Shortcut

The authors (led by Michael Bonitz) discovered a clever trick. They realized that instead of looking at the entire history of interactions, you can rewrite the rules so that you only need to know what happened right now and what happened a split second ago.

• The Analogy: Imagine instead of reading a 1,000-page diary, you just check a "status update" that summarizes the current mood of the crowd.
• The Result: This changes the math from a cubic growth (1,000,000 effort) to a linear growth (100 effort). It's like switching from a snail to a rocket ship. Suddenly, simulations that used to take years can be done in minutes. This allows scientists to study things like how fast electrons move in graphene or how ions stop in new materials.

3. The New Problem: The "Filing Cabinet" Issue

While the G1-G2 scheme is fast, it has a new bottleneck: Memory.
To make the "status update" work, the computer has to store a massive 4-dimensional spreadsheet (a tensor) that tracks how pairs of electrons interact.

• The Analogy: The old method was slow because the historian had to read too many books. The new method is fast, but it requires a library the size of a city just to store the "status updates." If the system is too big (like a large chunk of metal), the computer's hard drive fills up instantly.

4. The Fixes: How to Shrink the Library

The paper proposes two creative ways to solve this memory problem:

A. The "Embedding" Strategy (The VIP Section)

Instead of simulating the whole city, you only simulate the "VIP section" (the specific area you care about, like a specific chemical reaction) in high detail.

• The Analogy: You treat the VIPs with a full team of bodyguards and historians. For the rest of the crowd (the "environment"), you just assume they are a generic, calm background noise. You don't track every interaction of the background crowd; you just estimate how they might bump into the VIPs.
• Benefit: This drastically reduces the size of the spreadsheet you need to store, allowing you to simulate larger systems.

B. The "Quantum Fluctuation" Strategy (The Dice Roll)

This is a more radical idea. Instead of calculating the exact interaction for every single pair of electrons (which creates the huge spreadsheet), you use randomness.

• The Analogy: Imagine you want to know the average weather in a city. Instead of putting a sensor on every single tree and house, you throw 10,000 dice. Each die represents a "possible path" the weather could take. You run the simulation for all 10,000 paths and take the average.
• Benefit: This replaces the massive 4D spreadsheet with a collection of much smaller 2D lists. It turns a deterministic, memory-heavy calculation into a statistical one that is much lighter on the computer's memory.

5. What Did They Actually Simulate?

To prove their new methods work, they applied them to real-world scenarios:

• Hubbard Clusters: Tiny islands of atoms where electrons dance around each other.
• Graphene: A super-thin sheet of carbon. They simulated how it reacts when hit by a laser pulse, showing how electrons jump between energy levels.
• Ion Stopping: They modeled what happens when a fast-moving ion (like a charged atom) crashes into a material. This is crucial for understanding nuclear fusion or how radiation damages materials.

Summary

This paper is a "how-to" guide for supercharging the simulation of quantum matter.

1. The G1-G2 Scheme made the calculations fast (linear time) by removing the need to look at the entire history of interactions.
2. The Embedding Approach made the calculations smaller by focusing only on the important parts of the system.
3. The Quantum Fluctuation Approach made the calculations efficient by using randomness to avoid storing massive data tables.

Together, these tools allow scientists to simulate complex quantum systems for much longer times and larger sizes than ever before, opening the door to designing better solar cells, faster electronics, and new materials.

Technical Summary

1. Problem Statement

The theory of Nonequilibrium Green Functions (NEGF) is a powerful framework for simulating correlated quantum many-body systems in and out of equilibrium. However, standard numerical solutions of the Keldysh-Kadanoff-Baym equations (KBE) suffer from a severe computational bottleneck:

• Cubic Scaling: The computation time scales cubically with the number of time steps ($N_t^3$) due to the need to store and integrate over the full two-time history of the Green functions and self-energies.
• Memory Constraints: While the Generalized Kadanoff-Baym Ansatz (GKBA) reduces this to quadratic scaling ($N_t^2$) for simple self-energies (like the second-order Born approximation), it remains cubic for advanced approximations (GW, T-matrix).
• Limitation: This scaling prevents the simulation of long-time dynamics and large systems, which are essential for studying phenomena like thermalization, ion stopping, and ultrafast carrier dynamics in 2D materials.

2. Methodology

The paper introduces and expands upon the G1-G2 scheme, a reformulation of the NEGF equations that achieves time-linear scaling ($N_t^1$) regardless of the self-energy complexity.

Core Concepts:

• G1-G2 Reformulation: The authors demonstrate that the GKBA (specifically the Hartree-Fock GKBA or HF-GKBA) can be exactly reformulated into a set of coupled, time-local differential equations.
  • Instead of solving for the single-particle Green function $G(t, t')$ and the self-energy $\Sigma(t, t')$ with memory integrals, the scheme evolves the single-particle density matrix ($G^<$) and the correlated part of the two-particle Green function ($G$) directly.
  • The collision integral is expressed in terms of $G$, eliminating the need for time integrals over the history of the system.
• Extension to Advanced Self-Energies: The scheme is generalized beyond the simple second-order Born approximation (SOA) to include:
  • GW Approximation: For dynamical screening.
  • T-Matrix Approximations: Particle-particle (TPP) and particle-hole (TPH) for strong coupling and bound states.
  • Dynamically Screened Ladder (DSL): A combination of GW and T-matrix effects, including exchange diagrams, which was previously computationally infeasible for long times.
• Memory Bottleneck Solutions: Since the G1-G2 scheme requires storing a rank-4 tensor ($G_{ijkl}$), leading to $O(N_b^4)$ memory usage (where $N_b$ is the basis size), the paper proposes two strategies to overcome this:
  1. Embedding Approach: Divides the system into a "central" correlated region and an "environment" treated at a simpler level (e.g., mean-field). This reduces the dimensionality of the tensor to be stored. The paper derives a time-local embedding scheme compatible with G1-G2.
  2. Quantum Fluctuations Approach: Replaces the direct computation of the rank-4 tensor with a stochastic method. By treating fluctuations of the single-particle Green function as random variables (Stochastic Polarization Approximation - SPA), the method computes two-particle correlations from products of single-particle quantities, reducing memory scaling to $O(N_\lambda N_b^2)$, where $N_\lambda$ is the number of stochastic realizations.

3. Key Contributions

• Exact Time-Linear Scaling: Proved that the G1-G2 scheme achieves linear scaling with simulation time for high-level self-energies (GW, T-matrix, DSL), matching the efficiency of Time-Dependent Schrödinger Equation (TDSE) or TD-DFT simulations.
• Stability and Conservation: Addressed stability issues (N-representability) in the DSL approximation by introducing contraction consistency and purification techniques, ensuring physical density dynamics.
• Embedding Formalism: Developed a time-local embedding self-energy that allows simulating open systems (e.g., ions impacting materials) without solving the full system's KBE, maintaining linear time scaling.
• Stochastic Quantum Fluctuations: Introduced the SPA-ME (Multiple Ensembles) approach, which eliminates the rank-4 tensor bottleneck entirely, enabling simulations of very large systems far from equilibrium.

4. Results and Applications

The authors validated the scheme through several benchmark simulations:

• Hubbard Clusters: Demonstrated linear CPU scaling for SOA, GW, and DSL approximations on Hubbard chains. The G1-G2 scheme was shown to be faster than standard HF-GKBA after only ~30 time steps.
• Ion Stopping in Plasmas: Simulated the stopping of highly charged ions in 1D quantum plasmas. The G1-G2 scheme successfully captured energy dissipation and thermalization dynamics, overcoming aliasing issues via damping or refined grids.
• Graphene Excitation: Applied the scheme to optical excitation of graphene (2D lattice). The simulation covered the entire Brillouin zone (324 k-points) for 50 fs, resolving carrier multiplication, inter-band polarization, and the effects of linear vs. circular polarization on valley-selective excitation.
• Charge Transfer: Used the embedding scheme to model resonant charge transfer between a highly charged ion and a correlated material (Hubbard ring), showing excellent agreement with full two-time simulations but at a fraction of the cost.
• Fluctuation Approach Validation: Compared the Stochastic Polarization Approximation (SPA) against GW and exact diagonalization for Hubbard chains. Results showed excellent agreement in the weak-to-moderate coupling regime, validating the stochastic elimination of the rank-4 tensor.

5. Significance

This work represents a paradigm shift in the computational simulation of correlated quantum systems:

• Feasibility of Long-Time Dynamics: By reducing scaling from $N_t^3$ to $N_t^1$, the G1-G2 scheme makes it possible to simulate ultrafast processes over thousands of time steps, which was previously impossible for correlated systems.
• Access to High-Level Physics: It enables the routine use of advanced self-energies (GW, T-matrix, DSL) that capture screening, strong coupling, and bound states, providing a more accurate description of real materials than mean-field or simple scattering models.
• Scalability: The combination of the G1-G2 scheme with embedding and stochastic fluctuation methods addresses the memory bottleneck, opening the door to simulating large-scale heterogeneous systems (e.g., interfaces, nanostructures) and complex transport phenomena.
• Broad Applicability: The framework is applicable to diverse fields including condensed matter physics (2D materials, quantum dots), nuclear physics, and plasma physics, offering a unified tool for non-equilibrium many-body problems.

In conclusion, the paper establishes the G1-G2 scheme as a robust, scalable, and accurate method for non-equilibrium many-body simulations, effectively removing the historical computational barriers that limited the application of NEGF theory to complex, long-duration dynamics.