InflationEasy: A C++ Lattice Code for Inflation

InflationEasy is a C++ lattice code that extends the capabilities of LATTICEEASY to simulate nonlinear scalar field dynamics in an expanding universe, enabling fully nonperturbative studies of inflationary regimes, primordial black hole formation, and scalar-induced gravitational waves through features like a nonperturbative $\delta N$ method.

The Gist

Imagine the early universe as a giant, bubbling pot of cosmic soup. For decades, scientists have tried to understand how this soup behaved right after the Big Bang, specifically during a period called Inflation, where the universe expanded faster than the speed of light.

Usually, scientists study this soup using "perturbation theory." Think of this like trying to predict the weather by assuming the wind is always a gentle breeze. It works great for calm days, but if a massive hurricane hits (which happens when the universe gets very chaotic), the gentle breeze math breaks down.

Enter InflationEasy.

What is InflationEasy?

InflationEasy is a new computer program (written in C++) that acts like a high-tech, 3D video game engine for the universe. Instead of assuming the universe is calm, it simulates the "soup" on a giant 3D grid (a lattice), watching every single bubble and swirl interact in real-time.

Here is the breakdown using everyday analogies:

1. The "No-Split" Rule (The Whole Picture)

Most old programs try to separate the "background" (the calm ocean) from the "waves" (the storms). They calculate the ocean first, then add the waves on top.

• InflationEasy's approach: It doesn't split them. It simulates the ocean and the storm together. It treats the universe as a single, chaotic, nonlinear entity. This allows it to see what happens when the waves get so big they crash into each other, creating tsunamis that standard math can't predict.

2. The Digital Grid (The Lattice)

Imagine the universe is a giant 3D checkerboard.

• The Problem: If you draw a wave on a checkerboard, the corners of the squares mess up the wave's shape. It's like trying to draw a perfect circle using only square pixels; the edges look jagged.
• The Fix: InflationEasy has a special "correction lens." It knows that because the grid is made of squares, the waves move slightly differently than they would in a smooth, continuous universe. It mathematically adjusts for this "pixelation" so the results are accurate, no matter how big the squares are.

3. The "Time Travel" Calculator (The $\delta N$ Method)

One of the hardest things to measure in the early universe is Curvature Perturbation ($\zeta$). This is essentially a map of how "bumpy" the universe is.

• The Analogy: Imagine you are trying to measure how long a race took, but the runners are running on different terrains (some on sand, some on ice).
• How it works: InflationEasy uses a clever trick called the $\delta N$ method. Instead of just watching the race, it asks: "If I start every runner at the same time, how much later does the runner on the ice finish compared to the runner on the sand?"
• By measuring these tiny time delays at the end of the simulation, the code can instantly calculate exactly how bumpy the universe became, without needing complex, messy math.

4. The Echo Chamber (Gravitational Waves)

When the universe is super bumpy, it doesn't just create matter; it creates ripples in space-time called Gravitational Waves (like sound waves in a drum).

• The Two Sources: InflationEasy tracks two types of these ripples:
  1. The Inflationary Ripples: Created during the big expansion, like the initial drumbeat.
  2. The Re-entry Ripples: Created after inflation, when the bumpy regions fall back into the "normal" universe and crash into each other, like the echo bouncing off a canyon wall.
• The code calculates the "sound" (energy) of these ripples, helping scientists predict what detectors like LISA (a future space telescope) might hear billions of years later.

Why is this a Big Deal?

• It's for the "Wild" Stuff: Standard tools fail when the universe is chaotic (like when forming Primordial Black Holes). InflationEasy thrives in that chaos.
• It's Accessible: It's written in C++ (a common coding language), but the author designed it to be lightweight. You can run it on a standard laptop, not just a supercomputer.
• It's Open: It's free for anyone to download, tweak, and use. If you want to test a new theory about how the universe started, you can just change a few lines of code and hit "Run."

Summary

Think of InflationEasy as a cosmic weather simulator. While other tools can only predict sunny days, InflationEasy can simulate the most violent, chaotic storms in the history of the universe, correcting for the digital "pixels" of the computer screen, and telling us exactly what kind of "echoes" (gravitational waves) those storms left behind. It turns the abstract math of the Big Bang into a visual, interactive story.

Technical Summary

1. Problem Statement

Lattice simulations have become standard tools for studying the nonlinear dynamics of the early universe, particularly in regimes where perturbation theory fails (e.g., preheating and cosmological phase transitions). While several public codes exist (e.g., LATTICEEASY, DEFROST, CosmoLattice), they are primarily designed for post-inflationary dynamics.

• The Gap: There is a lack of dedicated tools to simulate the inflationary phase itself using a fully nonlinear lattice approach. Standard perturbation theory often breaks down in scenarios involving large fluctuations, non-Gaussianities, or specific potentials (like ultra-slow-roll) relevant for Primordial Black Hole (PBH) formation and Gravitational Wave (GW) backgrounds.
• The Need: A lightweight, accessible code is required to evolve scalar fields on an expanding 3D lattice during inflation, compute the curvature perturbation $\zeta$ non-perturbatively, and account for scalar-induced gravitational waves (SIGWs) generated both during and after inflation.

2. Methodology

InflationEasy is a C++ code that solves the Klein-Gordon equation for a canonical scalar field in a flat FLRW spacetime using conformal time.

A. Physical Framework

• Equations of Motion: The code evolves the inflaton field $\phi$ and the scale factor $a(\tau)$ simultaneously. It uses the Friedmann equations to determine the background expansion, calculating average energy density $\langle \rho \rangle$ and pressure $\langle p \rangle$ directly from the lattice.
• Fixed Metric Approximation: The simulation assumes a fixed FLRW metric ($g_{\mu\nu} = a^2(\tau)\eta_{\mu\nu}$) without metric perturbations ($\delta g_{\mu\nu} = 0$). This is valid in the decoupling limit where the slow-roll parameter $\epsilon \ll 1$ and gradient energy is subdominant.
• No Background/Perturbation Split: Unlike standard perturbation theory, the inflaton field and its fluctuations are evolved together as a single nonlinear entity.

B. Numerical Implementation

• Discretization: Space is discretized on a cubic lattice ($N_{pts}^3$ points) with periodic boundary conditions. Spatial derivatives are computed using second-order central finite differences.
• Modified Dispersion Relation (Key Innovation): To correct for lattice artifacts, the code uses an effective wavenumber ($k_{eff}$) derived from the discrete Laplacian rather than the naive lattice momentum. This ensures that the dispersion relation converges to the continuum form in the infrared and makes physical observables (like power spectra) independent of the lattice spacing choice.
• Initial Conditions: Fluctuations are initialized as a classical background plus quantum fluctuations drawn from a Bunch-Davies vacuum. Crucially, the mode functions incorporate the lattice-corrected dispersion relation ($k_{eff}$) to ensure consistency between initialization and evolution.
• Time Integration: The default integrator is a second-order symplectic leapfrog scheme (with RK4 and adaptive RK45 available). Time steps are rescaled to maintain a constant step in cosmic time.

C. Key Algorithms

1. Non-perturbative $\delta N$ Calculation:
   • Instead of linearizing, the code computes the comoving curvature perturbation $\zeta$ directly from the lattice.
   • It employs a "separate universe" approach: after the main evolution, each lattice point evolves independently (neglecting gradients) until it reaches a reference field value $\phi_{ref}$.
   • $\zeta(\vec{x})$ is calculated as the local difference in e-folds: $\zeta = N(\vec{x}) - \langle N(\vec{x}) \rangle$.
2. Scalar-Induced Gravitational Waves (SIGWs):
   • During Inflation: GWs are sourced by the nonlinear dynamics of the inflaton field ($S_{ij} \propto \partial_i \phi \partial_j \phi$).
   • Post-Inflation: The code maps the super-horizon $\zeta$ from the inflationary simulation to the Newtonian potential $\Phi$. It then evolves $\Phi$ linearly in a post-inflationary fluid background to capture GW generation during horizon re-entry.
   • The tensor modes are evolved on the same lattice, with Transverse-Traceless (TT) projection applied in Fourier space using the effective momenta.

3. Key Contributions

• First Dedicated Inflationary Lattice Code: Fills the gap between preheating codes and inflationary perturbation theory, enabling fully nonlinear studies of the inflationary epoch.
• Lattice-Corrected Dispersion: Introduces a robust prescription ($k \leftrightarrow k_{eff}$) for initial conditions and output analysis, eliminating artifacts related to grid spacing and ensuring results match analytical predictions in the continuum limit.
• Unified SIGW Framework: Provides a single simulation pipeline that captures GWs generated during inflation (via inflaton nonlinearities) and after inflation (via horizon re-entry of scalar perturbations), preserving non-Gaussian features throughout.
• Accessibility and Modularity: Written in C++ but designed to be lightweight and easy to modify. It supports standard laptops for modest resolutions ($128^3$–$256^3$) and includes Python notebooks for visualization.

4. Results and Validation

• Benchmarking: The code was tested on an Ultra-Slow-Roll (USR) potential, known for generating a large peak in the power spectrum (relevant for PBHs).
• Outputs:
  • Successfully reproduced the evolution of the mean inflaton field, velocity, and energy components.
  • Generated the power spectrum of curvature perturbations ($P_\zeta$) and the 1-point probability distribution function (PDF), demonstrating significant non-Gaussianity.
  • Calculated the dimensionless tensor power spectrum ($\Delta_h^2$) and GW energy density ($\Omega_{GW}$), showing contributions from both inflationary and post-inflationary phases.
• Performance: On an Apple M3 Max, a full simulation (inflation + $\delta N$ + GWs) for a $128^3$ lattice takes approximately 9 minutes and 38 seconds.
• Convergence: The code includes built-in checks for energy conservation and allows users to vary lattice size ($N_{pts}$) and box size ($L$) to verify that physical results are independent of numerical cutoffs.

5. Significance

• Beyond Perturbation Theory: InflationEasy allows researchers to explore regimes where standard perturbation theory fails, such as models with large non-Gaussianities or enhanced small-scale power.
• Primordial Black Holes & GWs: It is a critical tool for modeling the formation of Primordial Black Holes and predicting the stochastic gravitational-wave background, which are key targets for future observatories like LISA and PTA experiments.
• Unified Approach: By treating scalar and tensor sectors within a single nonlinear framework, it avoids the inconsistencies that arise when piecing together separate perturbative calculations for different epochs.
• Community Resource: As a publicly available, open-source tool with clear documentation and example notebooks, it lowers the barrier to entry for studying nonlinear inflationary dynamics, fostering broader adoption in the cosmological community.

In summary, InflationEasy represents a significant methodological advancement in computational cosmology, providing a robust, non-perturbative framework to simulate the inflationary universe and its observable signatures with high fidelity.