introduction
The book “Reality Is Not What It Seems”, by Carlo Rovelli, is an introduction to Loop Quantum Gravity, written by one of the theory’s founders. The theory is an attempt to overcome the apparent contradictions between relativity and quantum mechanics. It is one of the two big theories on the matter taken seriously by the physics community, the other being string theory.
I read up on string theory a long time ago, and it excited me then, as it does now. Indeed, it crept into my poetry, particularly anticipating the metaverse. So I wasn’t surprised to discover I found this theory very exciting too.
A lot of my excitement has to be a result of the superb quality of the text itself. Rovelli takes a very complex and bizarre idea, Loop Quantum Gravity, and makes clear and, to some extent, obvious. I felt, when I had completely the book, that I understood a lot of what he was trying to say. Of course, I only understood it at a superficial level, but all the same, I felt I understood. Part of that has to be down to the translators from the book’s original Italian, Simon Carnell and Erica Segre. But even though the precise language belongs to them, everything else about the book, obviously, comes from the author.
Carlo Rovelli says in the introduction that he has to explain his understanding of quantum gravity by starting from the very beginning of western science, and moving forward to his now. He writes up that history rather well, particularly by concentrating on more than the usual tribe (admittedly, one can’t really write a history of physics and ignore Einstein, for example). Rovelli’s write–up is insightful and entertaining, and without supplication.
Furthermore, Rovelli introduced me to the Greek philosopher Democritus, whose work has been lost. We know some of what Democritus wrote from Plato’s criticisms of his work, from Aristotle’s responses, but not from Democritus’s himself. (Incidentally, I never know whether to be angry with dark aged scribes for losing so much material of immense value, or to praise them for saving so much material of immense value. Clearly, they had to make difficult decisions.)
But before I discuss the core of the book, a discussion of the concepts of loop quantum theory and quantum gravity, I have to confess I have rather a lot of baggage. Now, this baggage helps me understand what’s been said, to some extent. Unfortunately, it means I have to explain the baggage to explain my response to the book. Anyway, similar baggage has given me poetry (anticipating the metaverse), so I’m not giving it up!
baggage
As a poet, I know a lot of what people get out of a book comes from what they bring to it. What people read in my poetry is not always what I thought I wrote. Sometimes, they’re reading something quite different. Sometimes, they’ve seen something that really is there but that I didn’t spot for ten years. This is just as true with abstract photography.
So it should be clear that a lot of my understanding of this book comes from what I’m bringing to it. In particular, I brought an idea I had many decades ago, a very computer nerd idea, on how to build a particular computer game, a game that was never written. I can only explain my excitement to the book’s real ideas in terms of my software’s rather silly ideas, which, interestingly, don’t seem to contradict the book, as I read it, and help me understand some of the weirder concepts that arise out of the theory.
Many years ago, when I was young and spotty, my school had a small computer, a small DEC PDP-8/E. This was incredibly unusual for a school in the late 1970s, and a great boon to me: I was, and still am, a natural computer nerd. Anyway, I was a schoolboy, so I did what many a schoolboy in the following years did with a computer, I wrote a computer game. It was a version of the game Monopoly. But that PDP-8/E was a very small computer (it had 8K of 12 bit memory), which supported three terminals. There wasn’t enough space for the tables for the fines which were charged when landing on a property. So I cheated, I calculated the fines. The result for a particular fine was wrong, but I got that values roughly right, so overall the economic balance of the game worked out: and, importantly, the program fitted in the memory available.
So what, you might think? Well, that’s where I learnt that radical optimisation of resources can work.
Later, at poly, I wanted to write a free space game. I wanted to try and make the background seen in the game not entirely inaccurate, so a player could look out and see the correct stars, the correct planets, indeed, the correct everything that was big enough to see, including other players doing something nasty a long way off. I wanted that sky to reflect changes that occurred in the game, quickly. I wanted to use as little memory as possible.
That means I wanted to draw objects a long way off. And since those objects moved, some predictably, some entirely at the whim of other players, I couldn’t paint scenery, I had to actually draw things. I had to draw things as they were, where they were. Space might be empty, but it’s full of a lot of stuff, and I wanted to draw as much of that stuff as I could. This presented problems: it takes time I didn’t have to draw a lot of stuff, and it takes memory I didn’t have to keep information about that stuff. I had to radically optimise my data to keep the time and memory needs practical.
The obvious way to store positional information would be to store it with each object. The obvious way to access information about what was where would be to store it in a table (e.g. look up cell x, y, z in the table to find a reference to what’s there). That would mean the information was stored twice, in the table indices, and in the object. I had little memory.
But then it clicked, I wanted to show things from a particular viewpoint, and I could use ray tracing to work out what to display. This is a graphics technique that says if you look in direction X, then draw everything that’s on the line from where you are until something big stops any further drawing, or you run out of space. To do that, I had to connect items to each other by their relative positions. This means that I needed to connect particular positions together, not look up absolute positions. I could connect the objects together, and get rid of that table. I saved some memory. Actually, that was not a slam dunk, because I had to store those relative positions, so the amount of memory saved depending on the number of positions.
So that didn’t save enough. Each object stored its x, y and z position. Each object also referenced its neighbours. But in the context of the game, I didn’t care about the exact measurements of an object, I just cared about what was on the ray trace line. I wanted, when looking in a particular direction, to know how far away something was, and what it looked like. That’s it. I didn’t care about its absolute position. I could get rid of its x, y and z position, but I would still need angle and distance from each close neighbour.
Ok, so I could imagine a line going off into the distance, and I could imagine drawing anything that touched that line. To draw it properly, I’d need details of an item itself, it’s orientation relative to the neighbour of interest, it’s measurements, it’s dimensions, and it’s distance from me. I couldn’t reduce most of that stuff, most belong to the object.
So I decided to separate the object from its position. For this discussion, I’m not worried about orientation, although it is of course important for complex objects. What interests me here is the dimensions of the space occupied. Remember, I want to calculate the distance from the eye to every object on the line of sight. If I were to do this absolutely correctly, I’d store the space occupied measurements in all three dimensions, and calculate the angles of entry and exit of the line of sight for each dimension, and from that work out how much distance was covered. Of course I wasn’t going to do that!
Instead, I decided to pretend that the object existing in a sphere of a fixed size, and added that size to the distance calculation. I replaced three dimensions with one value. I also decided to set things up so I could pretend all the sphere’s touched between neighbours, so the distance between two neighbours was worked out by adding their sizes together and dividing by two. Thus, to calculate distance on the line of sight meant going to the neighbour roughly that direction, add the neighbour’s size, going to the next neighbour in the appropriate direction, adding that size, and so on. The distance become nothing more than the sum of neighbours’ sizes. That’s fast.
There are a number of obvious problems with this, and I’ll cover some now.
- First of all, the distance calculated will be too big. However, I think it the error should average out to some factor of the average angle between the neighbours crossed. Of course, being lazy, I decreed it to be 15 degrees, then thought about cutting the sizes stored by an appropriate amount (I think it’s about 2%, but I am probably wrong), but then decided, nope, things are 2% father away than they were.
- Secondly, the supposéd straight line of site zig zagged like a drunken walk. Still, it got me the result I wanted, and quickly: one of the only cases where drunks are more efficient.
- I would have to determine by experiment which objects should be designated connected. That would depend on what would work in the display, the fewer the better so not too much space was wasted, but enough to ensure the line of sight calculation wouldn’t get too daft.
- There are dimensions, there are directions, but they arise out of the connectivity between objects, not the objects themselves (which have only one dimension). I’ve not thought of the most efficient way to manage that, mind: had I built this code, that would require experimentation.
- But there’s another issue. Well, it’s not a game issue: it doesn’t matter there if the neighbourly objects are actually connected consistently, but I think that does matter in geometry. I could be wrong. But if extremely small objects were absolute spheres, did only have one value, size, which applied to all dimensions, and distance between two objects was based on adding the two sizes together, does geometric consistency require that all objects always touch? Perhaps this determines what objects are neighbours. But, actually, but given the game’s connection mechanism is a pointer, not a position, the apparent geometric inconsistency doesn’t matter.
- If I were to presume things always touched, movement would be a nuisance because size would change to reflect different positions. Nah, I don’t need that — but what I do need is accurate relative positions, so movement would mean constantly changing those positions. That would be slow. Or I could have cells of relative positions and move objects across those cells? Clearly, this needed further thought (that it never got).
There are a couple of advantages, though.
- By only using one value for size, e.g. by forcing everything to be a hypersphere, many calculations are way easier and way faster: that’s far less computer power;
- I could either save three quarters of the memory used for size, or I could quadruple the size of the variables used to store the value. This would increase my playspace by many orders of magnitude (in eight bit memory, from an 8 bit to a 32 bit integer, e.g. values from 255 to 4,294,967,295).
In computer terms, those two advantages so outweigh the niggles that I’d put up with the niggles.
The further away the objects were, the less I needed to know about them. They were either seen, or not, and that was it. All I needed to store was their space occupied, a single number. In the line of sight calculations, and if the right units were chosen, that number would also be the time taken to cross the object’s space. In this thought experiment, space time has become an attribute of mass energy: a radical result for a never–written computer game.
how this relates to the book
The end of the introduction section of the book discusses the odd effects of quantum mechanics, most of which have been confirmed by experimentation. Consider it a precursor to the even weirder results of quantum gravity.
For example, the path taken by quantum objects moving from A to B is zig–zagged, just like the line of sight calculation. Of course, where they go is determined by probability, and has nothing to do with line of sight calculations, but that line of sight algorithm illustrates a zig zag straight line.
One of the persistent beliefs of a number of proposed ideas for digging deeper into the quantum world is hidden variables. These hidden variables would supposédly explain, amongst other things, why quantum objects, when going in a straight line (for example), actually zigzag. After all, additional variables really do explain why small objects suspended in air actually jump about the place all the time (that’s down to very tiny bees with very big feet). But I don’t think hidden variables are necessary: after all, my thought experiment made it clear to me that such behaviour can be caused by too few variables, not too many.
quantum gravity
Newton said we can’t measure time, only presume it. (Measuring time with a clock is actually comparing the events we’re measuring against the beat of the pendulum; it’s not measuring time, it’s comparing two things). Einstein showed there is no absolute time. In quantum gravity, it’s gone, there is no time. There is, however, change, change that arises out of the behaviour of quantised space, change of one thing in relation to another. This is not new to me either. Let us imagine, for a moment, that there is absolute time, and that during a period of absolute time, absolutely nothing changes. Nothing whatsoever changes. There are no quantum leaps, there is no movement. Given consciousness is based on brain behaviour, and there is no change, then the brain cannot behave, thus it cannot change, so their is no conscious awareness of the lack of change.
This shows the concept of absolute time, when considered like this, makes no sense. What we experience is change, not time. Indeed, actually, I believe time is a cultural artifact, a product of the way our society works. Time has got more and more precise over … er … time, as our technology has developed. But Time need not be some external imposed absolute, it can arise out of the way the natural world works.
And that’s what quantum gravity suggests, that there is no absolute time; time arises from change. Indeed, change doesn’t occur in time, change causes our experience of time. That causes me no problems either. In my thought experiment, time arises out of the relationship between the objects: that single size is x, y, z and t, in that it took time t to cross the object (at the speed of line of sight!).
Now, remember, remember, remember, my thought experiment is not a valid theory of anything, it is only a mechanism which allows me to feel I understand a lot of what is being described. There are aspects of the theory which are not covered by my game, unsurprisingly. But there are a lot of unexpected synergies between my toy and the theory which help me appreciate it.
My design emphasised the units of space at the centre, and didn’t properly consider the links between them. The theory says that, actually, what’s important are those connections, and what happens between one connection and another is not so important. It sees the connections as an area of contact between grains of space.
terminology
It must be said at this point that I have a problem with some of the language used to described the basic components of space. The book says, if I’ve understood it correctly, the space time arises out of these components, that what’s important is the relationship between them. The problem is the book uses grains, and other similar terms, to identify the objects. A grain, in real life, occupies three dimensional space, whereas a space grain creates it. The concept is wrong gets in the way of what’s been described. A term that does not have an innate spacial component would be better. Furthermore, what’s important is the relationship between grains, not the grains themselves. I would suggest a terminology that emphasises the relationship between objects, which does not come with meanings that contradict the ideas. Of course, I’m presuming my understanding is correct, which it probably isn’t.
My own field, computing, is full of such terminology, although the problem with these terms is that they are usually associated with particular informational structures. For example, a relation is a link between tables in a relational database, and spacetime may be many things but it is not a database. Class terminology would probably work, but I suspect it’s too general. I think, rather than using terminology from information science, it might be more useful to look for inspiration in the terminologies of social structures. There are lots of different kinds of relationships described there; one might fit rather well.
In fact, I’d like to steal a word from computing to use instead of grain. A pixel has no dimensionality, it’s just a dot, but pixels used together create the illusion of space time. You look in a 2D screen and see a 3D world, you’re actually just looking at some pixels which, acting together, create the image of the nasty monster you’re about to frag. Now, of course, these do not properly compare to loop quantum grains, as grains do not, but pixels do have the innate implication of creating space time from the way they behave together. A grain is definitely the wrong term, a pixel less do.
One thing the competing string theory gets right is their terminology. It’s full of humour. It has striking terms that are memorable because they are funny, yet that humour subverts the normal meanings of the words, so allow the actual meaning, in the context of the theory, to stand on its own. The obvious example to me is P–brane. In string theory, or perhaps M theory, brane is a space–time structure, a surface on which universes exist. The word comes from membrane. There are a variety of different possible structures, including an M–brane and a P–brane, if I recall correctly. The letters do have their own particular meanings, but the intentional humour behind the terms’ combination makes them immediately memorable.
Back to the book
As Rovelli makes absolutely clear throughout the book, loop quantum gravity is one of a number of competing explanations to merge relativity and quantum mechanics. One may be right, the others will be wrong. It is a solidly founded, well worked out, internally consistent theory, unlike almost all the ideas one encounters, but it remains completely unproven. Obviously, the author is invested in his theory, but he has the decency not to allow his investment to dominate his nous. As such, his book offers a rare slice of honesty in the market of ideas in print: even if you’re not interested in physics, it’s worth reading the book to see that ideas can be presented with honesty yet still win praise. I can imagine, in consequence, that this book would either be banned or biblified were it ever found near a marketing department.
What makes the book so good, though, is the quality of the explanations, of the expression of the ideas. Any book that can get such an excited and intense response out of me gets my approval, unsurprisingly. I came with my baggage, above, and it helped me understand the book. My baggage is nonsense, of course, but the book is so well written and contains such high quality, clear, and apparently simple explanations that I can happily riff away in my little corner of nonsense. I find this book intensely inspiring.
Reality Is Not What It Seems
Carlo Rovelli
Pengiun
ISBN 978-0-141-98321-9