On simulations and mechanical similarity

Simulations are not a mere copy of reality. They should not be.

A perfect copy of a system would be about as useful as the original system in understanding its internal workings.

Simulations of physical systems abstract away from some properties of the system and keep some other properties. In this process some symmetry can be gained.

This face is not (exactly) left-right symmetric:

A real face

A real face (mine)

This simulated face is:

A simulated face

A simulated face

The abstraction gained some symmetry over the original: there is now a transformation that sends it into itself, reflection. This works because some information was lost in making the model.

From faces to star clusters

Similarly, simulations of star clusters where stars are represented by point-particles interacting gravitationally lose lots of information. Point particles are not stars: they do not have a radius, a chemical composition, an age. Thus the dynamics of the simulation is completely independent on what goes on inside the stars, while the dynamics of a real star cluster is not. This has an interesting consequence: there is a transformation that sends the simulated system into itself (a symmetry) that was not there in the real system.

The new symmetry is a mechanical similarity that works when the only force present is gravity: I can change all the masses in the simulation by a factor A, all the distances by another factor B, all the velocities by yet another factor C and, if the three factors are in the right proportions, the simulation evolves exactly in the same way.

If you like the technical detail:

The (classical) Lagrangian of a system of N point particles interacting gravitationally is

Classical Lagrangian of a gravitational N-body system

Classical Lagrangian of a gravitational N-body system

Now multiply all the masses by A, the lengths by B, and the velocities by C:

The same, after changing units

The same Lagrangian, after changing units

As long as

C^2 = A/B

the new Lagrangian is the old one multiplied by a constant, and the equations of motion do not change. For example if I double all the masses and all the distances while leaving the velocities alone (A=B=2, C=1) nothing will change: the Lagrangian function will double, resulting in the same equations of motion.

So there is no such a thing as the real size or age of a simulated cluster of stars (in parsec). The physical phenomena that define a meter or a second in the real world (atomic clocks, etc…) are simply not there in the simulation.

A nagging question

However, it is still very natural to ask: how long did you evolve your simulation, in years? A million years or a billion or twenty billion? Such an easy question and I cannot answer it! Worse yet, I have to explain that the question itself is meaningless… Not an easy task!

So let’s ask a different question. How long is this bug, in meters?

The picture of a bug

A bug


Of course you can measure it on your screen with a ruler and get a figure. But a different person with a different monitor will get a different figure. The question would be somewhat more meaningful if the picture had a way to determine scale internally, like this:

A bug and a coin (for scale)

A bug and a coin


This picture of a bug (from which I cropped the previous one) was posted on Reddit requesting identification of the bug. The coin is added for scale.

We need to add the coin because the information about the actual size of an object is lost in the process of taking a picture. There is no way (without detailed information on the camera and the set-up of the picture) to know the size of the bug in meters from its size in pixels. But if we add an object with a known size (the key here is that both the poster and the reader are likely to both have a coin handy, or at least remember one) we can recover the absolute size of the bug.

Stellar evolution can take on the role of the coin in simulations of star clusters: I can say that I run a simulation for one billion years if a star the mass of Sirius (twice the Sun) just left the main sequence. If I simulate stellar evolution toegether with dynamical evolution then there are two time scales, the ratio of which is absolute, like the ratio of the bug size to the coin size.

To be honest this still does not solve the problem (if we want to call a problem the ability to simulate infinite systems in one stroke!), and I will talk about it in a follow-up thought.

TL;DR: If stellar evolution is on in a simulation I can tell for how long it was evolved in years. Otherwise I can’t.