Illustris Project

The Illustris project is a large cosmological simulation of galaxy formation, completed in late 2013, using a state of the art numerical code and a comprehensive physical model. Building on several years of effort by members of the collaboration, the Illustris simulation represents an unprecedented combination of high resolution, total volume, and physical fidelity. The About page contains detailed descriptions of the project, for both the general public and researchers in the field.

The website, present the scientific motivation behind the project, a list of the collaboration members, key results and references, movies and images created from the simulation data, information on public data access, and tools for interactive data exploration. The short video below is a compilation made from some of the movies available on the Media page, where many additional visualizations are available.

https://www.illustris-project.org/

This is an interesting project.

The production a true to physics simulation of the universe could aid A.I. as a testing environment.

The Illustris project is an ongoing series of astrophysical simulations run by an international collaboration of scientists. The aim was to study the processes of galaxy formation and evolution in the universe with a comprehensive physical model. Early results were described in a number of publications. The project publicly released all data produced by the simulations in April, 2015. Key developers of the Illustris simulation have been Volker Springel (Max-Planck-Institut für Astrophysik) and Mark Vogelsberger (Massachusetts Institute of Technology). The Illustris simulation framework and galaxy formation model has been used for a wide range of spin-off projects, starting with Auriga and IllustrisTNG (both 2017) followed by Thesan (2021), MillenniumTNG (2022) and TNG-Cluster (to be published in 2023).

The original Illustris project was carried out by Mark Vogelsberger and collaborators as the first large-scale galaxy formation application of Volker Springel's novel Arepo code.

The Illustris project included large-scale cosmological simulations of the evolution of the universe, spanning initial conditions of the Big Bang, to the present day, 13.8 billion years later. Modeling, based on the most precise data and calculations currently available, are compared to actual findings of the observable universe in order to better understand the nature of the universe, including galaxy formation, dark matter and dark energy.

The simulation included many physical processes which are thought to be critical for galaxy formation. These include the formation of stars and the subsequent "feedback" due to supernova explosions, as well as the formation of super-massive black holes, their consumption of nearby gas, and their multiple modes of energetic feedback.

The main Illustris simulation was run on the Curie supercomputer at CEA (France) and the SuperMUC supercomputer at the Leibniz Computing Centre (Germany). A total of 19 million CPU hours was required, using 8,192 CPU cores. The peak memory usage was approximately 25 TB of RAM. A total of 136 snapshots were saved over the course of the simulation, totaling over 230 TB cumulative data volume.

A code called "Arepo" was used to run the Illustris simulations. It was written by Volker Springel, the same author as the GADGET code. The name is derived from the Sator Square. This code solves the coupled equations of gravity and hydrodynamics using a discretization of space based on a moving Voronoi tessellation. It is optimized for running on large, distributed memory supercomputers using an MPI approach.

Illustris Spin-Off Projects

The Illustris simulation framework has been used by a wide range of spin-off projects that focus on specific scientific questions. IllustrisTNG: The IllustrisTNG project, "the next generation" follow up to the original Illustris simulation, was first presented in July, 2017. A team of scientists from Germany and the U.S. led by Prof. Volker Springel. First, a new physical model was developed, which among other features included Magnetohydrodynamics planned three simulations, which used different volumes at different resolutions. The intermediate simulation (TNG100) was equivalent to the original Illustris simulation. Unlike Illustris, it was run on the Hazel Hen machine at the High Performance Computing Center, Stuttgart in Germany. Up to 25,000 computer cores were employed.

Physics Engines

Attempting to replicate all the laws of physics and other realities into a simulation by hand is about having a real world mirror for A.I. to test and train against. Both engineering and physiology. Physics engines come in two types, general and specialised. Such as

  1. PhysX: Powerful engine from NVIDIA, offering advanced features like fluid dynamics and vehicle simulation, but has a commercial license.
  2. Bullet Physics: Open-source, widely used, good for various simulations, including rigid bodies, soft bodies, constraints, and vehicles.
  3. SPHysics: Open-source, particle-based fluid simulator, well-suited for complex fluid interactions.
  4. Newton: Powerful soft body engine with robust features and a focus on realistic deformable object simulation.

Emergence of the Universe

The universe, the laws of physics, did not come about through a process of hard-coding rules in the way we might write computer code. Instead, this type of thinking is a fundamental code that propagates over iteration into a state of the universe. Evolving from a fundamental piece of code. This analogy helps to illustrate how complex systems can emerge from simple, foundational principles through iterative processes.

Example of a time-stepping loop as the basis of many simulation codes.

#include stdio.h

// Function to initialize the system with initial conditions
void initialize_system() {
    // Example of setting initial conditions
    printf("Initializing system...\n");
    // Initialization code here (e.g., setting initial positions, velocities, etc.)
}

// Function to calculate the next state based on the laws of physics
void calculate_next_state() {
    // Example of calculating the next state
    // This would include physics calculations such as updating positions, velocities, etc.
    printf("Calculating next state...\n");
    // Calculation code here
}

int main() {
    // Set initial conditions
    initialize_system();

    // Set simulation parameters
    double total_time = 100.0;  // Total simulation time in arbitrary units
    double time_step = 0.1;     // Time step size in the same units

    // Main simulation loop
    double current_time = 0.0;
    while (current_time < total_time) {
        // Calculate the next state based on the laws of physics
        calculate_next_state();

        // Update current time
        current_time += time_step;
    }

    printf("Simulation complete.\n");
    return 0;
}

As 99% of the universe is electromagnetism, the universe is more like algebra. A path between two potentials, a starting value, an ending value and guided permutations. For example, a swamp and a predator equals an alligator. Where a and c are the condition for b to arise.

a+c→b
swamp+predator→alligator
start condition + end Condition → x

This equation suggests that the combination of a and c leads to the emergence and transformation of b. An animation of a difference rather than a traditional evolutionary algorithm. Some abstract product between two states caused by the identity of those two states. When human beings build a car it is driven by electromagnetism, a need to transport results in a motorised car is a lightning bolt between two cases, the potential need for transport and an adventure into invention. This is the path of the lightning bolt, and each time it makes ground, it is a completed circuit. The programming language of the universe is paths, the paths between two states form the circuit and the solution for that particular problem. Similarly, the universe emerges using that language. That is the code to put into the simulation code that at some iteration spawn the universe as we know it, to some probability.

Retraining is learning and synthetic data generation space.

An LLM is in a space where it generates synthetic data and then re-trains itself.

  1. https://github.com/AkshitIreddy/Interactive-LLM-Powered-NPCs

Self re-training and self-generation of synthetic data. That would be learning.

Grounding would be in a space where physical laws apply, so a simulation would have a grounding for quality. Level of proficieny aside at some stage its design is to hack reality.

Another Version

#include <stdio.h> #include <math.h>

// Constants

#define G 6.67430e-11 // Gravitational constant #define NUM_PARTICLES 3 // Number of particles in the system

// Structure to represent a particle

typedef struct {

double x; // x position

double y; // y position

double vx; // x velocity

double vy; // y velocity

double mass; // mass

} Particle;

// Array to hold the particles

Particle particles[NUM_PARTICLES];

// Function to initialize the system with initial conditions

void initialize_system() {

// Set initial conditions for each particle

particles[0] = (Particle){0.0, 0.0, 0.0, 0.0, 1.0e5}; // Central massive particle

particles[1] = (Particle){100.0, 0.0, 0.0, 10.0, 1.0}; // Orbiting particle

particles[2] = (Particle){-100.0, 0.0, 0.0, -10.0, 1.0}; // Another orbiting particle

printf("System initialized with %d particles.\n", NUM_PARTICLES);

}

// Function to calculate the next state based on the laws of physics

void calculate_next_state(double time_step) {

for (int i = 0; i < NUM_PARTICLES; i++) {

double ax = 0.0;

double ay = 0.0;

// Calculate gravitational forces from other particles

for (int j = 0; j < NUM_PARTICLES; j++) {

if (i != j) {

double dx = particles[j].x - particles[i].x;

double dy = particles[j].y - particles[i].y;

double distance = sqrt(dx * dx + dy * dy);

double force = (G * particles[i].mass * particles[j].mass) / (distance * distance);

ax += force * dx / distance / particles[i].mass;

ay += force * dy / distance / particles[i].mass;

}

}

// Update velocities based on acceleration

particles[i].vx += ax * time_step;

particles[i].vy += ay * time_step;

}

// Update positions based on velocities

for (int i = 0; i < NUM_PARTICLES; i++) {

particles[i].x += particles[i].vx * time_step;

particles[i].y += particles[i].vy * time_step;

}

}

int main() {

// Initialize the system

initialize_system();

// Set simulation parameters

double total_time = 1000.0; // Total simulation time in arbitrary units

double time_step = 1.0; // Time step size in the same units

// Main simulation loop

double current_time = 0.0;

while (current_time < total_time) {

// Calculate the next state based on the laws of physics

calculate_next_state(time_step);

// Update current time

current_time += time_step;

}

return 0;

}

Another

#include <stdio.h> #include <math.h>

// Constants

#define G 6.67430e-11 // Gravitational constant #define NUM_PARTICLES 3 // Number of particles in the system #define INITIAL_TEMPERATURE 1.0e32 // Initial temperature in Kelvin #define INITIAL_SCALE_FACTOR 1.0e-15 // Initial scale factor (arbitrary units) #define TOTAL_TIME 1000.0 // Total simulation time in arbitrary units #define TIME_STEP 1.0 // Time step size in the same units

// Structure to represent a particle

typedef struct {

double x; // x position

double y; // y position

double vx; // x velocity

double vy; // y velocity

double mass; // mass

} Particle;

// Array to hold the particles

Particle particles[NUM_PARTICLES];

// Function to initialize the system with initial conditions

void initialize_system() {

// Primordial state initialization

double temperature = INITIAL_TEMPERATURE;

double scale_factor = INITIAL_SCALE_FACTOR;

// Inflationary epoch

scale_factor *= 1.0e30;

// Symmetry breaking

temperature *= 1.0e-15;

// Particle formation

particles[0] = (Particle){0.0, 0.0, 0.0, 0.0, 1.0e5}; // Central massive particle

particles[1] = (Particle){100.0, 0.0, 0.0, 10.0, 1.0}; // Orbiting particle

particles[2] = (Particle){-100.0, 0.0, 0.0, -10.0, 1.0}; // Another orbiting particle

printf("System initialized.\n");

}

// Function to calculate the next state based on the laws of physics

void calculate_next_state() {

// Gravitational interaction calculations

for (int i = 0; i < NUM_PARTICLES; i++) {

double ax = 0.0;

double ay = 0.0;

// Calculate gravitational forces from other particles

for (int j = 0; j < NUM_PARTICLES; j++) {

if (i != j) {

double dx = particles[j].x - particles[i].x;

double dy = particles[j].y - particles[i].y;

double distance = sqrt(dx * dx + dy * dy);

double force = (G * particles[i].mass * particles[j].mass) / (distance * distance);

ax += force * dx / distance / particles[i].mass;

ay += force * dy / distance / particles[i].mass;

}

}

// Update velocities based on acceleration

particles[i].vx += ax * TIME_STEP;

particles[i].vy += ay * TIME_STEP;

}

// Update positions based on velocities

for (int i = 0; i < NUM_PARTICLES; i++) {

particles[i].x += particles[i].vx * TIME_STEP;

particles[i].y += particles[i].vy * TIME_STEP;

}

printf("Next state calculated.\n");

}

int main() {

// Set initial conditions

initialize_system();

// Main simulation loop

double current_time = 0.0;

while (current_time < TOTAL_TIME) {

// Calculate the next state based on the laws of physics

calculate_next_state();

// Update current time

current_time += TIME_STEP;

}

return 0;

}

  

📝 📜 ⏱️  ⬆️