COSMOS: A numerical relativity code specialized for PBH formation

COSMOS is a standalone, OpenMP-parallelized C++ numerical relativity code designed to simulate primordial black hole formation by solving the Einstein equations in 3+1 dimensions using specialized non-Cartesian scale-up coordinates and fixed mesh refinement to handle non-linear gravitational dynamics.

The Gist

The Big Picture: Building Black Holes from Scratch

Imagine the early universe not as a smooth, calm ocean, but as a choppy sea with giant waves. Sometimes, these waves get so tall and heavy that they collapse in on themselves, forming Primordial Black Holes (PBHs). Unlike the black holes we usually hear about—which are the corpses of dead stars—PBHs were born instantly from the "wrinkles" in the fabric of space and time right after the Big Bang.

Scientists want to understand how these black holes form, but the math is incredibly difficult. It's like trying to predict exactly how a specific drop of water will splash when it hits a puddle, but the puddle is expanding, and the water is made of pure gravity.

The Solution: COSMOS (The Digital Laboratory)

This paper introduces COSMOS, a computer program (written in C++) designed specifically to simulate these black hole births. Think of COSMOS as a high-tech, digital wind tunnel for gravity. Just as engineers build scale models of cars to test how air flows around them, physicists use COSMOS to build "scale models" of the early universe to see how gravity behaves when things get messy.

How It Works: The "Zoom Lens" Trick

One of the biggest challenges in this simulation is that there are two very different sizes happening at once:

1. The Tiny Spot: The specific region where the black hole is collapsing (very small).
2. The Big Picture: The entire universe expanding around it (very large).

If you try to look at the whole universe with a microscope, you lose the big picture. If you look at the whole universe with a wide-angle lens, you can't see the tiny details of the collapse.

COSMOS solves this with a "Smart Zoom" feature.
Imagine you are watching a movie of a collapsing star. Most of the screen shows the vast, empty universe. But as the star starts to shrink, the camera automatically zooms in super close on that one spot, adding more "pixels" (resolution) exactly where they are needed. This allows the computer to handle the tiny, violent collapse without needing a supercomputer the size of a city just to calculate the empty space around it.

The Ingredients: What's in the Simulation?

To run the simulation, COSMOS mixes two main ingredients, like a baker making a specific type of dough:

1. The Fluid: A perfect, smooth fluid that represents the matter in the early universe. It follows simple rules (like a balloon inflating or deflating).
2. The Scalar Field: A ghost-like energy field that ripples through space.

The program solves the Einstein Equations (the rulebook for how gravity works) to see how these ingredients interact. It asks: "If I start with a specific bump in the universe, will it smooth out, or will it crush itself into a black hole?"

The "No-Prep" Advantage

Usually, setting up a physics simulation is like baking a cake where you have to pre-mix the batter (solve complex math equations) before you even turn on the oven.

COSMOS is different. Because it simulates a universe that is already full of fluid (rather than empty space), it can start with the batter already mixed. The initial conditions are set up so perfectly that the computer doesn't need to spend time solving difficult "elliptic" equations to get started. It just hits "run" and watches the story unfold. This makes the code lighter, faster, and easier for other scientists to install and use.

What the Paper Shows (The Examples)

The paper includes three "test drives" to show how the code works:

1. The Simple Wave: It simulates a small, gentle ripple in space to prove the code matches known, simple math.
2. The Perfect Sphere (Adiabatic): It simulates a perfectly round, collapsing bubble of space. The paper shows a picture of the "lapse function" (a measure of how time flows) and how the computer zooms in on the center as the black hole forms.
3. The Ghost Wave (Iso-curvature): It simulates a collapse caused by that "ghost-like" energy field mentioned earlier.

In all these cases, the code successfully finds the moment a Black Hole is born (technically called an "apparent horizon") and maps out its shape.

Why This Matters

The authors aren't just making a toy; they are building a specialized tool for a specific job. While other tools exist for general black hole collisions (like those from merging stars), COSMOS is the specialized wrench designed specifically for the unique, messy, and expanding environment of the early universe.

By making this code open and easy to use, the authors hope other scientists can extend it to ask new questions about the universe's hidden history, potentially explaining what dark matter is made of or why we see gravitational waves today.

---

In a nutshell: This paper presents COSMOS, a specialized computer program that acts like a "smart zoom" camera for the early universe. It allows scientists to simulate how tiny wrinkles in space-time collapse to form the very first black holes, doing so efficiently by focusing its computing power exactly where the action happens.

Technical Summary

Technical Summary of COSMOS: A Numerical Relativity Code for PBH Formation

Problem Statement
Primordial black holes (PBHs) are hypothesized to form in the early universe from super-horizon primordial fluctuations with non-linearly large initial amplitudes, bypassing stellar evolution. Simulating their formation requires solving the Einstein equations under conditions where multiple length scales coexist: the microscopic size of the collapsing region and the macroscopic scale of cosmological expansion. Standard numerical approaches often struggle with the computational cost of resolving these disparate scales efficiently. Furthermore, obtaining initial data for spacetimes filled with fluid and scalar fields, rather than asymptotically flat vacuum regions, presents specific challenges regarding constraint equations.

Methodology
The paper introduces COSMOS, a C++ package designed to solve the Einstein equations in 3+1 dimensions specifically for PBH formation. The code is a C++ translation and evolution of the SACRA code, originally developed for different purposes.

• Physical Model: COSMOS models matter as a perfect fluid with a linear equation of state ($P = w\rho$) and a massless scalar field. The energy-momentum tensor is the sum of fluid ($T^{FL}_{\mu\nu}$) and scalar field ($T^{SC}_{\mu\nu}$) contributions. The system solves the Einstein equations ($G_{\mu\nu} = 8\pi G/c^4 T_{\mu\nu}$), the scalar field equation ($\nabla_\mu\nabla^\mu\phi = 0$), and the fluid conservation equations ($\nabla_\mu T^{FL}_{\mu\nu} = 0$). The fluid evolution follows the scheme established by Kurganov & Tadmor (2000) and Shibata & Font (2005).
• Numerical Techniques: To address the multi-scale problem, COSMOS implements:
  • Non-Cartesian scale-up coordinates: To efficiently resolve the collapsing region.
  • Fixed Mesh Refinement (FMR): To dynamically adjust resolution where necessary.
  • Parallelization: OpenMP is utilized to achieve practically acceptable computational speeds.
  • Dependencies: The code is designed with no external dependencies to facilitate easier installation and extension.
• Initial Data Construction: Unlike standard methods for asymptotically flat vacuum spacetimes that require solving elliptic differential equations, COSMOS generates initial data by adopting long-wavelength growing-mode solutions (up to next-leading order in the expansion parameter $\epsilon = k/(aH) \ll 1$).
  • For adiabatic fluctuations, the initial data is characterized by the curvature perturbation $\zeta(\vec{x})$.
  • For iso-curvature perturbations, it is characterized by $\Upsilon(\vec{x})$ associated with the massless scalar field.
  • The fluid distribution is generated to satisfy the Einstein constraint equations to within machine precision, eliminating the need for elliptic solvers.

Key Contributions

1. Specialized Software Release: The paper presents the public release of COSMOS, a tool specifically tailored for simulating PBH formation, distinguishing it from general-purpose numerical relativity codes.
2. Efficient Initial Data Generation: The code implements a method to satisfy constraint equations analytically via long-wavelength approximations, avoiding the computational overhead of elliptic solvers for initial data in cosmological fluid backgrounds.
3. Documentation and Examples: The package includes three demonstration examples intended for instructional purposes:
   • Evolution of a single-mode sinusoidal perturbation (validating against linear perturbation theory).
   • Adiabatic spherically symmetric initial fluctuations (demonstrating apparent horizon formation).
   • Spherically symmetric iso-curvature perturbations driven by a massless scalar field.
   • These examples utilize low resolution to demonstrate functionality rather than high-precision results.

Results
The paper provides visual and qualitative results from the included examples:

• Linear Validation: The time evolution of the trace of the extrinsic curvature ($trK$) for a small sinusoidal fluctuation is shown to match the solution of the linear perturbation equation.
• Horizon Formation: Simulations of adiabatic and iso-curvature perturbations successfully demonstrate the formation of apparent horizons. The code outputs data files (e.g., ini_all.dat) allowing users to reconstruct the geometry and matter distribution at the moment an apparent horizon is detected.
• Mesh Refinement: Visualizations confirm the operation of the fixed mesh refinement layers, showing distinct regions of resolution (lowest, 1st, and 2nd layers) around the collapsing region.

Significance and Claims
The authors position COSMOS as a specialized tool to support the growing interest in PBHs, particularly in the context of gravitational wave observations. The paper claims that the code offers a streamlined approach to simulating non-linear gravitational dynamics in the early universe by:

• Providing a self-contained C++ environment that is easy to install and extend for various scientific settings once the source code is understood.
• Offering a robust method for handling the specific initial value problem of cosmological fluids without elliptic solvers.
• Serving as a foundation for previous and future research, as evidenced by its use in numerous publications by the authors and collaborators (e.g., Yoo et al., 2013; Okawa et al., 2014; Escrivà & Yoo, 2025).

The paper modestly notes that the included examples are for demonstration and instruction, with resolution intentionally kept low. It also clarifies that some advanced functions used in the authors' prior publications may not be present in the public release, implying that reproducing all past results may require additional, non-public implementations.