In the summer of 2019, I had the opportunity to workon a group project around Causal Set theory. The goal of the project was to build a Causal Set generator (we will explain what this is in this article). I was working with another student (both in 1st year) under the supervision of PhD students.
So, what is Causal Set theory? It is a theory that tries to solve the problem of quantum gravity, that is how can we reconcile quantum mechanics with gravity as described by general relativity. On one hand quantum mechanics is a well verified theory of matter, on the other general relativity has to do with space-time. Popular solutions to this problem include string theory and quantum loop gravity. Causal Set theory is a more obscure solution. In Causal Set theory we approach the problem by quantising space-time itself. What if space-time is actually not a continuum but is an aggregate of “space-time atoms”? We call these “atoms” events as they are a moment in time at a location in space and we would expect them to be around the Planck scale.
We can make a quick estimation of the number of events in our universe. So, the 4-dimensional volume of our Universe is 13.8 billion light years cubed (the spatial volume) times 13.8 billion years (the age) which gives roughly 5.7 x10−43 m^3 s. The size of an event can be found similarly by taking the cube of a Planck length (1.616255x10−35 m) times a Planck time (5.39 × 10−44 s) which gives 2.3 x10−148 m^3 s. By dividing the first result by the second one we get something of the order of 10192 events which is a mindbogglingly big number.
So how do we build our Universe from these events? We build what we call a causal set which is a graph that shows events and their causal relations. So, if a line is drawn between two events then something happening in one event can causally affect something in the other event. There is also an order that is defined such that an event can precede another one.
Figure 1 and figure 2 are two examples of causal sets. Let’s use figure 2 to explain some of the basic
concepts. The elements C and D are connected by a link so they are causally related, furthermore D precedes C as D is beneath C in the diagram. Causal sets possess something called transitivity: that is if an event x precedes an event y and y precedes z then x precedes z. So, x and z are causally related. In figure 2, element D precedes element A. The order in the causal set gives us an arrow of time. Lets now look at elements A and B, these elements are not causally related, we cannot say that one precedes the other. In fact, at C the universe branches out into two distinct regions that are causally independent (on either sides of the blue line). So effectively the regions at each sides of the blue line can be seen as independent universes as anything happening in one region cannot affect the other region.
Interpreting the structures seen in causal sets is very interesting, if we can find structures that correspond to things we see in our own Universe, we might be able to find the causal set that describes it. So, for example, in figure 1 we can see a causal set in which a single element precedes all other elements. This means the universe described by this causet (short for causal set) spawned from a single point in space-time, this can be seen as a Big Bang. Similarly, a single element is preceded by all other elements, this can be seen as a Big Crunch.
In Causal Set theory, the Universe is not static, new events are born constantly. So, space-time is always increasing, this is reminiscent of inflation which we observe in our own Universe. This means we can come up with an algorithm that governs how causal sets grow.
Our end goal was to be able to generate different types of causal sets by building a causet generator using the programming language Python. The algorithm we used for our causal set generator is a classical sequential growth (CSG) algorithm in which elements are added one at a time following certain probabilities. The algorithm is as follows:
- You create k elements/events that have no relations these are called ‘minimal’ elements no other element precedes them
- For the nth element we flip a biased coin (the bias depends on k and another parameter called t) to see if it will be minimal
- If it is not minimal, we choose k elements in the list of all previously generated events that will precede the new event
- Repeat 2 to 3 for however many elements you need
Figure 3 shows how a causal set is generated using a CSG algorithm. From the starting element there is two possible causets but as the number of elements increases the number of possible causets increases exponentially. Programming the algorithm in Python is simple. But we wish to build the largest possible causal set so we must optimize every aspect of our code. The first trick is to use linear algebra whenever possible. In our program we represent causal sets using matrices. This is shown in figure 4, a causal set of N elements is represented by an N by N matrix. If there is a link between events x and y we change the (x,y) element in the matrix to a 1 otherwise it’s a 0. We do not need to change both (x,y) and (y,x) so we can use only half of the matrix.
These matrices are very useful because we can use some clever linear algebra operations (that I will not detail here) to find characteristics of the causet such as the number of elements or the number of minimal elements (shown in blue in figure 4).
We also used something called sparse matrices which is a more compact way of storing matrices containing a lot of zeroes. Instead of storing the whole matrix we only keep the coordinates of the ones in the matrix. So, for the matrix in figure 4 that would be: (3,1), (4,1), (3,5). Because our matrices are mostly zeroes we save a lot of space and our code runs better.
An example of the causal sets we were able to generate is shown in figure 5. This particular causal set contains 500 elements and we can already not distinguish every single link. When we ran our code to get our final data, we generated around 50 000 causal sets (only the matrix representations) with 5 000 elements each (in the end it was about 50 GB of data).
Once we were able to generate causal sets, we had to decide on what to analyse, we chose to count the number of minimal elements in our causets and see how it changed if we varied the parameters of our algorithm (t and k). Figure 6 and 7 are two of the graphs we were able to make. Figure 6 shows the distribution of the number of minimal elements (m) for causets with k=2 and t=0.2, whereas figure 7 shows the average of m for different combinations of k and t (the colours of the tiles correspond to different values of m)
In the end we were not able to find a physical interpretation for our results. Nonetheless this project was a very fun and motivating way of finishing my first year of physics at university. At the end of the day our lack of knowledge of theoretical physics and advanced mathematics meant we were not able to fully grasp Causal Set theory and make our project very meaningful. But it was great to get introduced to this very theoretical concept and to play with some of its ideas. It was also great fun to use the bits of Python we had learned throughout the year as well as learning how to optimize code.
.svg)
.png)