How would you program a model of a universe?

The goal is to create a computer program that creates a virtual universe with the fewest possible rules and shortest amount of code. The model doesn't have emulate our known universe.

The only requirement is that after injecting initial data the virtual universe becomes self-sustaining and ever evolving so that based on the fundamental rules and fundamental elements more complex structures and interactions can be formed.

So an advanced version of "Game of Life".

1. How would you define the core model and rules of such virtual universe?

2. What would be the minimum amount of "initial data input" required to start and keep the virtual universe running (assuming ~infinite computational and memory resources)?

Designing a three dimensional system is a lot harder than a simple Game of Life though.

With regards to the kind of rule you speak of, a cellular automata cell in a 3D environment has at most 26 neighbours in the lattice. You could easily increment that to 27 if you wish to make its behaviour depend on its prior state (or even 53 if it you want it to depend on its 26 neighbours’ current state plus 27 prior states of itself and its neighbours). I built such systems (albeit on dynamic networks and 2D automata lattices) for my thesis nigh on 18 years ago. It’s quite utterly trivial.

>Let's assume you have nearly infinite computation resources.

I think it's more fun to assume you don't. You need not simulate every water molecule in the ocean for life to emerge.

Imagine you had a hash table of precomputed interactions between various simulation elements across all scales. In such a system, the computational cost of simulating a single protein would be similar to that of two galaxies colliding.

A planet for example would simply be a vast hierarchy containing a chain of approximated behaviors, each node in that chain containing its own hierarchy.

The really fun part is trying to envision how changes at very low levels in this chain would ripple upwards and affect the simulation at larger scales. Thus far I've only imagined it as analog to node invalidation in a typical scene graph data structure, where you flag it "dirty" and it's queued for recomputation on the next frame.

Therefore, I reasoned that these low-level rules you're talking about may manifest upward in scale. If you created layered approximations of observable behavior, you could essentially capture the output of these rules even if not directly discovering them at a low level.

If you have a protein, a plant, planet and galaxy all on equal footing in terms of how they're approximated and simulated, then perhaps one could factor out commonality from each and deduce some sort of low-level rules from that.

With respect to our reality being an ancestor simulation, I'd say it's highly likely. You might be interested in looking at Bostrom's simulation hypothesis, if you already haven't.