I confess to being pleased by the result as, though I like very much what the LQG community is exploring, I would be surprised if differences in the velocity or polarization of photons yielded proof of the granular nature of space. My personal guess is that discrete spacetime doesn’t work that way.

What’s a little more disappointing is the way that the result has been reported on the web. There have been lots of statements either implying that because of this result, the voxels of spacetime must be very small, or that the idea of discrete spacetime is itself suddenly less plausible. Most likely these comments have arisen because the article originally posted on the ESA’s own website says the following: “It has shown that any underlying quantum ‘graininess’ of space must be at much smaller scales than previously predicted.”

The author appears to be a fellow called Markus Bauer, who, probably in the name of journalistic expediency, chose to leave out the key phrase “if loop quantum gravity models are correct”. His statement might have been okay if LQG was the only discrete spacetime model in town, but that’s far from true these days.

Can we forgive him? Yes. But I personally do so with a small sigh. His article sent small ripples across the web, leading to slightly wrongy statements all over the place, such as this remark in Wired UK: “An astrophysicist’s attempt to measure quantum ‘fuzziness’ to find out if we’re living in a hologram has been headed off at the pass by results suggesting that we’re probably not.”

I suppose the reason why I’m a little sad about this is because I feel like this kind of interpretation isn’t good for science. Science, as the marvelous Karl Popper pointed out many years ago, advances via refutation. It’s great that a handful of LQG models got ruled out. Philippe Laurent wasn’t ‘headed off at the pass’–he scored an awesome goal! Having a theory shot down isn’t a problem, it’s a cause for cheering because now there’s more lovely science work to do and we have better data to do it with!

Keeping this distinction straight in the minds of the public is important, IMO, because this feature of science is rather different from the way that we normally tend think about things. For instance, if a politician makes an incorrect prediction, we often condemn him or her for getting it wrong. If they change their mind a lot, we call them a ‘flip-flopper’ rather than ‘someone who’s learning’. Scientists must be professional flip-floppers and spend their entire careers getting things wrong. If they aren’t, they’re not learning. And if they’re not learning, they’re not doing their jobs.

The modern academic system already rewards people way too much for protecting pet theories and trying to look unassailably correct. In doing so, it prevents many brilliant people from making theoretical strides without fear. So let me add one voice to web chorus and say this: “Way to go Philippe Laurent! Way to go Quantum Gravity Theorists! Keep coming up with those testable predictions. Quantum gravity badly needs them!”

The subject of the competition: Is Reality Digital or Analog?

How could we not take part? Tommaso and I agreed that we should both submit an essay. I didn’t win, but I’m delighted to say that Tommaso received a prize. For those who’re interested, my submission can be found here, and Tommaso’s here.

Where my first algorithm used a single machine head, my second one uses two. And instead of simply picking up and putting down bits, this new algorithm swaps them from one head to the other. Machine-head A passes its data to head B, and B passes its data to A. What this means is that the new algorithm is a lot faster at turning order into chaos while being no less reversible.

On top of this, the new algorithm produces some eerie physics-like results from time to time, the reasons for which still aren’t entirely clear to me. The new algorithm working on a block of bits also looks peculiarly like something rotting or rusting—something I’ve not seen before in a simple algorithm.

Once again, I’m struck by the peculiar corrosive beauty of these programs but am still not sure what they’re good for. You can find the simulations here.

During my collaboration with Tommaso Bolognesi at CNR-ISTI last autumn, we were looking for ways to create sparse, pseudo-random data structures. Specifically, we wanted sparsely-connected directed acyclic graphs (a requirement for building spacetime-like causal sets, a term I explained in my last post.) However we soon discovered that there weren’t any classes of data structures for which we could get the kind of results we were looking for.

For those of you with a math/computing background, this might sound like a slightly odd statement, because there have been algorithms to build sparse, pseudo-random matrices for ages. However, none of these algorithms were as simple as we wanted, or as adaptable as we wanted. For starters, most of these algorithms require that you explicitly represent numbers somewhere in your code. For our purposes, this pretty much ruled them out immediately. What we wanted was for the sparseness of the data to emerge naturally out of a process without us having to impose extra layers of interpretation on it.

To get a sense of what I mean, let’s take a look at turmites. Turmites are very simple programs of a sort that Tommaso and I have explored and are great at producing pseudo-random data. The way they work is very straightforward: you have a network of memory slots hooked up according to some geometrical rule. You also have a machine-head that can move across that network and change the contents of the memory slot it’s sitting on. You then create a simple rule for moving the machine-head based on the contents of the slot where it’s located. It’s basically like a 2D Turing Machine.

The simplest such program is probably Langton’s Ant—the first turmite ever discovered. It runs on a square grid of black and white cells, and has an operating rule says:

• If you’re on a white cell, make it black, turn right, and step forwards.
• If you’re on a black cell, make it white, turn left, and step forwards.

That’s it. It’s about as computationally simple as you can get and yet the output is so unexpected that computer scientists still don’t have much in the way of useful proofs about its behavior.

At face value, turmites look like a terrific fit for the sort of randomness we want to create. Furthermore, there are plenty of turmites that you can run for as long as you like, and never get repeating data. However, if you take a look at the kinds of patterns that turmites create, you may notice something about them. The patterns are all pretty dense. What I mean by this is that the balance of black and white squares that they generate is usually pretty much equal. Sure, some of them make denser patterns than others, but the density is never all that low. Furthermore, you definitely don’t get to choose in advance how dense the pattern is going to be. Your choice of ant algorithm decides that for you. You don’t have any say in the matter.

The reason for this is that in order for the ant to produce random-looking data, its behavior needs to be unpredictable. And its behavior can only be unpredictable if it has a nice rich mix of black and white cells to work with. Take away the mixture and the behavior stops being unpredictable.

One way to get very sparse data out of a turmite is to pick a rule that’s got a large number of different states. In other words, instead of only permitting you to put a one or a zero in each slot that the turmite visits, you can put one of a larger range of values, say, for instance, one of ten different values. Then, to get your sparseness, you throw away everything except one of the states when you examine the results. However, we didn’t like this solution either, as it required us to take the output of the algorithm and apply some kind of arbitrary filter to it. So we were stuck. We couldn’t even create turmites of the sort that we wanted, let alone causal sets.

Then, shortly after I got back to the US, a solution of sorts to the turmite version of the problem occurred to me. Whether the same kind of algorithm will turn out to be applicable to networks is unknown, but it seems like a an interesting starting point.

The idea here is that instead of having a rule for turning a slot in the grid on or off, instead you have a rule for picking up a bit or putting it down. This allows you to populate your environment with data as sparse as you like, and know that the density will never change as long as the program runs. There’s one other twist, so to speak. Rather than running the program on a grid of infinite size, you run it on a grid of finite size, but you hook up the edges of that grid such that leaving the top of the grid brings you back at the bottom of the grid shifted one row to the left. Likewise, leaving through the bottom brings you back a row to the right. The left and right edges of the grid are also hooked up the same way, so that the whole grid is slightly twisted.

An odd set-up, admittedly, but what it gives you is a turmite that takes whatever input you provide and mangles it for you without losing track of any of your bits. Because no bits are ever gained or lost, it also means that the ant should be reversible. We can write a program that can unmangle any mangled data we’re handed. It’s like a magic wand for turning order into chaos and back again—a kind of do-it-yourself entropy kit. In fact, it’s a little bit like a tiny universe with a finite supply of matter. Over time, everything becomes disordered, but it does so according to a rule that works as well backwards as it does forwards.

About fifty years ago, this would probably have been an awesome way of encoding messages. However, these days we have public key cryptography, so the utility of my algorithm is a little less obvious. However, there’s something about it that gives me a tingly feeling. It has practical uses, I’m sure of it. I’m just not sure what they are yet. Any ideas?

How to fold this approach back into a class of algorithms that will help build causal sets is something I’m still working on. I can use this method to approximate percolation dynamics by using the turmite to construct an adjacency matrix. However, that doesn’t help us build realistic spacetimes. Clearly, more work is required.

And now, for those of you who’ve been patient enough to read to the end, here’s another link to the simulation. Happy watching, and if you think of a use for this thing, let me know!

Is it possible to build networks that have the same properties as spacetime using simple algorithms, and if so, how?

I’ve had plenty to say on the subject of modeling space before this. However, what Tommaso was looking for was very specific. He wanted us to find ways to build causal sets. Causal set theory is probably the point of closest approach between digital physics and more mainstream quantum gravity research and it’s a fascinating subject. In a nutshell, causal set theorists believe that spacetime is most usefully thought of as a discrete structure and that the way to model it is to try to mimic the kinds of relationships between events that we see in relativity. To achieve this, they connect nodes using something called a partial order—a set of relationships that define which nodes must come before others, but which falls short of providing an exact numbering for all nodes.

Broadly speaking, the Causal Set Program uses two methods to build their sets. The first, called sprinkling, is to deposit nodes at random onto a surface, and hook them together based on the geometry of that surface. The other way, called percolation dynamics, is to add nodes one by one to a set, and randomly add links from existing members of that set to each new node.

Sprinkling is useful for exploring how causal sets behave but it has a huge problem: in order to construct the discrete structure of spacetime, you have to deposit your points onto a smooth spacetime first! Clearly, if we want to come up with a background-independent theory of physics, we need to build the sets some other way. On the other hand, percolation dynamics has all the nice statistical properties that physicists would like to see and doesn’t need a background, but sadly doesn’t actually produce graphs that look like spacetime (though people are working on that).

The right solution would seem to be to come up with a third way: a process that produces the right structures without needing a background surface. However, this comes with problems. The key features that differentiate spacetime-like causal sets from others are dimensionality and Lorentz invariance.

Dimensionality essentially says that we should expect the graph that we build to have some consistent number of dimensions, rather than just being a tangled mess. Lorentz invariance is a little trickier. What it implies is that if you build your network first and then lay the nodes onto a flat surface afterward, the positions of the nodes should appear random. There should be no way you can stretch or squish the network to make it look otherwise. This is vitally important because in order to treat every relativistic reference frame the same way, as special relativity says we must, we need about the same number of links between nodes in each frame.

Another way to say this is that, thanks to Einstein, we know that no matter how fast we’re moving, space will always feel the same to us. The way a causal set works is that each link corresponds to a step through time and space taken at a certain speed. So, if for some speed of travel, our network doesn’t have enough links, it’s definitely not going to feel the same to someone traveling through it. If this happens, our model has failed. The only way that people have ever found to make Lorentz-invariant causal sets is to have the network be random.

My collaboration with Tommaso was founded on a neat way around this problem that works like this:

• Because any causal set we can build is finite, it can only ever approximate perfect randomness.
• Furthermore, for a finite network of given size, we can always find some algorithm that can approximate that level of randomness through a deterministic process.
• Thus, no matter how big our network needs to be, we should still always be able to find an algorithm that could give rise to it.
• This will always be true so long as we believe that spacetime is discrete, that the universe has finite size, and that it has existed for finite time.

In essence, what this tells us is that just because the network we want to build needs to look random, that doesn’t mean that we can’t use a completely non-random method for building it. This is all great as far as it goes, but it leaves us with an enormous problem: how to find an algorithm that can build spacetime.

In the two months we had, Tommaso and I didn’t manage to crack this problem (otherwise you would have heard about it on the news by now) but we learned some fascinating things along the way. I hope to share some of them with you in my later posts.

However, in the mean time, there are plenty of really excellent introductory papers on causal sets that are very approachable for those who’re interested. While my favorite approach to discrete physics is a little different from the causal set methodology, I can recommend this field very highly to anyone interested in learning more about quantum gravity without taking on a full-time career as a string theorist.

The Game

Scott Aaronson here proposes a game where two players attempt to correlate their actions:

We’ve got two players, Alice and Bob, and they’re playing the following game. Alice flips a fair coin; then, based on the result, she can either raise her hand or not. Bob flips another fair coin; then, based on the result, he can either raise his hand or not. What both players want is that exactly one of them should raise their hand, if and only if both coins landed heads. If that condition is satisfied then they win the game; if it isn’t then they lose. (This is a cooperative rather than competitive game.)

Clarification: Bob and Alice can both raise their hands or both keep them down in the case where they don’t both throw heads. Also, the time interval within which they must raise their hands is too quick for them to share any information at light speed (ie the events form a space-like interval).

In a classical world, with no quantum-ish non-local correlations (what Einstein referred to as “spooky action at a  distance”), Bob and Alice can win at most 75% of the time, by keeping their hands down (or up) on every turn.  However, using particles with quantum entangled spin states, they can do better.  Aaronson refers to this, which allows Alice and Bob to win the game more than 80% of the time, by cleverly choosing which angles to measure these entangled particles’ spin.  I’d like to discuss a made-up world, where Bob and Alice can win this game 100% of the time, by virtue of the properties of physics in this imaginary world.

I like Aaronson’s review a lot, not because of what it has to say about NKS, but because the proof it contains. This proof, in my opinion, is one of those rare, wonderful moments in which a scientist with relatively mainstream views takes the time to refute a position in digital physics in a precise fashion. Out of such moments, stronger theories are made.

For those who’re interested, the review can be found here. I encourage all those who’re interested in this topic to take a look–particularly at Section 3.2.

For those who aren’t inspired to take a look, the gist of the proof is this: Any model that incorporates both quantum entanglement and special relativity is going to run into situations in which a measurement B in one reference frame precedes the event A that appears to precipitate it. The same situation must be viewable in other reference frames in which the events appear the other way around. The proof points out that a completely discrete model like the one Wolfram proposes lacks the quantum mechanical tools that usually help us resolve such scenarios. In the discrete case, either event A causes event B, or vice versa.

The proof is important because it’s not specifically directed at Wolfram’s ideas, but rather all fully discrete models of physics. What the proof proposes, in essence, is that complete discrete models are fundamentally incompatible with what we see in experimental physics.

I think I know what’s wrong with this proof and I’ll try to make my thinking on the topic clear here. If anyone out there disagrees with what I have to say, I’d be delighted to hear about it. To be honest, my idea of what’s wrong is so simple that I can’t quite believe that nobody else has said it. Quite possibly, there’s something massively obvious that I’m missing. If that’s the case, I can’t wait to learn what it is.

I believe that Aaronson’s proof fails because of the literal requirement of Assertion 2, which states:

R satisfies the relativity postulate. That is, assuming the causal network approximates a flat Minkowski spacetime at a large enough scale, there are no preferred inertial frames.

I would argue that while the proof may work so long as Assertion 2 is true, there’s no requirement that it hold. This is because we don’t know that spacetime actually conforms Minkowski space. We only know that whenever we observe objects traveling through space at less than the speed of light, their behavior is consistent with that model.

It’s true that every observation we’ve ever made has been rigorously, perfectly consistent with the Minkowski-space model, but we also know that we can never actually prove that spacetime conforms to Minkowski-space from basic philosophy of science. Notably, the work of Karl Popper.

To quote the mighty Wikipedia on Popper’s work:

Logically, no number of positive outcomes at the level of experimental testing can confirm a scientific theory, but a single counterexample is logically decisive: it shows the theory, from which the implication is derived, to be false.

In other words, we can never prove that something is true–only that it’s false. This concept is important here because spacetime is a bit like dark matter–we can never measure it directly. We can only ever measure the motion of particles traveling through it. I would argue that this changes the requirements for a working model of digital physics. Namely, the requirement becomes that particles within our model must always travel in a Lorentz-invariant fashion.

This distinction is key because if we can create other models of spacetime for which Lorentz-invariant motion always holds, but for which discretization works properly, then Aaronson’s proof fails for that case.

Are there such models? Doesn’t Special Relativity require Minkowski space? So far as I understand the topic, yes there are such models, and no, Relativity doesn’t need it. For an alternative model that I can’t find a problem with, all we need to do is a little algebra.

Here is the expression that defines the properties of Minkowski space, in units where the speed of light is 1:

s^2 = t^2 – x^2 – y^2 – z^2

To get something a little nicer, let’s just get rid of those pesky minus signs by moving our spatial axes to the other side of the equation. Then we get this:

t^2 = s^2 + x^2 + y^2 + z^2

Suddenly we have something that’s flat and local. But what does it mean in practice? It means that we need a simulation with an extra compact dimension, in addition to the three we’re used to looking at, that codes for the spacetime interval s. Motion in this compact dimension operates as a measure of the ‘subjective time’ that a particle experiences. With each iteration, particles travel at fixed velocity in some direction that combines motion in s, x, y and z. Simulation steps are then ordered along the axis t, which we might think of as ‘objective time’. I have a video of particles traveling this way on the web, and which I’ve mentioned in a previous post. You can find it here.

“But,” I hear you say, “that doesn’t look like Special Relativity, for a start, there’s a preferred frame of reference–namely the one through which we’re viewing the simulation”. Yes, it’s true that from outside the simulation, there’s a preferred frame, but there isn’t one when viewed from inside. Different reference frames are manifested as different angles with respect to the compact dimension, and motion in each direction is exactly the same. From within the simulation, measurements are completely consistent with the Minkowski-space model because the math governing them is identical.

“But what about Lorentz boosts?” you may ask. “What about Lorentz contraction? How come just one extra dimension is necessary? Don’t you need three?” Only one dimension is necessary because we know that to all extents and purposes, particles are point-like. Particles without extent don’t experience Lorentz-contraction. All of the physical properties that we observe of them emerge from their subjective experience of time.

Using this model starts making a difference when we get to the line in Aaronson’s proof at the bottom of page 10.

Then for all Z we require the following, based on what observers in different inertial frames could perceive:

This line and those that follow presuppose that in our discrete model, what an observer perceives as simultaneous is actually simultaneous. In other words, there is some discrete link directly connecting cause and effect. This is true in the Minkowski-space approximation, but in our compact-dimension model, it’s not. An observer perceives two events as simultaneous simply because the light from those events reaches him at the same time with respect to the objective time axis t.

What this means for examples such as the one that Aaronson raises, is that from outside our discrete simulation, we always know exactly when a particle interaction occurs, even if observers within the simulation may never be able to agree. It doesn’t matter that in some reference frames, effect B appears to precede cause A, because the perceived ordering of events no longer implies that the controlling simulation treats them the same way.

One of my current projects is a simulation that will hopefully make this point absolutely clear. I intend to track the subjective experiences of a large number of pseudo-particles traveling across a discrete space approximation that uses an extra compact dimension of the sort I describe. It is my belief that by constructing a secondary graph from the set of their subjective-time paths, it should be possible to obtain a causal set graph that approximates Minkowski space. Tools to measure the properties of such graphs have been developed by theorists working in Causal Set theory. By applying those tools, it should be possible to confirm that the experience of Special Relativity in a discrete simulation doesn’t require that the supporting graph mimic Minkowski-space directly.

This still leaves us with the topic of how exactly to encode quantum entanglement in a fully discrete system, as Aaronson’s proof relates as much to this topic as it does to relativity. This topic, though, is perhaps one for another post. However, it is worth stating that modeling entanglement in its most basic form appears to be extremely straightforward. The models I’ve built so far use something rather like the ‘long-range thread’ approach that Wolfram describes in his book, and it appears to work fine. Encouraging a particle to collapse into one of two spatially disjoint positions is easy in discrete models–the Jellyfish algorithm I’ve described in previous posts revealed this behavior on its own without any coaxing from me.

Ironically, the trickiest problem I’ve encountered in this area isn’t entanglement, but the encoding of information in geometric form. In order to create a working Bell Inequality simulation, we have to be able to simulate particle orientation and have two particles that retain their orientation in a coordinated way that is linked to the shared particle state we wish to collapse. This turns out to be tricky–particularly at the tiny scales at which my simulations run. It may be that there are better ways to manage Bell’s Inequality than the tools I’m currently using. Dan Miller, who also posts on this blog, has some interesting ideas in this arena which he will hopefully share in a later post.

To conclude, let me say that there is one old saying with which I ferociously disagree, and it is this: better to keep your mouth shut and have others think you’re a fool and to open it and remove all doubt. This sentiment negates learning. If you think I’ve illustrated ignorance or folly in this posting, call me on it. If you believe in science, this is your opportunity to share what you know to a willing audience. From me, you will hear only thanks.

The way I tend to describe this idea is as follows:
How do you tell if the universe is smooth or discrete? You can’t build an apparatus directly to test for smoothness, because whatever apparatus you build, there will always be some level of detail that it fails to examine. Thus, it might be that the universe is discrete, but simply made of granular events at some scale that you haven’t yet measured.

Thus the only way that you can determine whether you’re in a smooth universe or not is by doing something that would be computationally impossible in a universe that contained a finite amount of information. In other words, can you beat Turing’s Halting Problem, or Godel’s Incompleteness Theorem? If you can, then you can go to bed at night comfortably certain that the Calculus enthusiasts are right. The universe can do impossible things, and therefore physical theories that depend on continuous variable are just fine. On the other hand, of course, if you can’t beat Godel’s theorem, then you have to consider the ghastly possibility that the application of calculus to physics is only a handy approximation, as it is in every other field where it’s applied, rather than an absolute truth.

The Arxiv article is the first time I’ve seen people in the theoretical physics community come to these conclusions on their own. What’s wonderful about it is that it points the way toward a falsifiable experiment some time in the future that might actually settle the question. It hinges on the fact that a superluminal computer should be able to pack an infinite number of calculations into a finite period of time–something that digital physics forbids. Thus, if we can build an optical computer and an electron bath, neither of which seem impossible, then we can feed our computer a theorem-checking program and a nice list of Godel sentences. Then we go grab a bite of lunch and when we come back, the answer to one of the most contentious questions in physics has been answered for us. Hoorah!

It perhaps doesn’t come as a surprise that I’m skeptical of the idea of hyper-computers. Nevertheless, it’d wonderful to be wrong. A universe capable of miracles might be a fun place to live. Roll on optical computing technology. Your first grand application awaits!

This sparsity is only to be expected. Irregular graphs of the kind I use are inherently noisier than the tidy lattices employed by CAs. That noisiness gives us enough robustness to model curved space and approximate quantum uncertainty, but means that we can’t rely on exact patterns of cell activation to represent physical phenomena. However, this isn’t to say that we can’t build interesting and exciting patterns in this paradigm–far from it. And in this post, I’m going to explain how it can be done.

The first step is to point you at the slides I used in my talk at the JOUAL conference in Italy last year. You can find them here:
http://www.alexlamb.com/science.html

This talk covered some research I did on extending Jellyfish–most notably to create pseudo-particles on three dimensional graphs that polarize and retain their orientation as they move. Just as they can fly in any direction, they can polarize in any direction too, without requiring any change to the algorithm.

The core concept that I share in the slides to achieve this couldn’t be easier: you put one Jellyfish inside another. I call this a ‘steed-rider relationship’. You advance an ordinary pseudo-particle with simple iterative steps to move it forward, (that’s the steed), but you also adjust the position of pseudo-particle the same size that’s trapped inside it, (the rider). Half of the rider’s front nodes are located in the front node set of the steed, the other half are in the back. That’s it. Voila: polarization. The particle self-organizes to give you a nice naturalistic property that’s unexpectedly robust.

What’s also interesting about this kind of particle relationship is that the steed’s update algorithm isn’t affected by the rider it carries. This means that the rider manifests as an intrinsic property of the steed, rather than as a physical sub-particle. You can break the steed up so that it’s in multiple locations at once and the property will be retained. This gets useful if you extend the model a little further.

By creating a rider that’s much smaller than its steed, and changing its update rule a little, you can pretty easily create a rider that moves around inside its steed as it travels. And because in three dimensions the steed always tends toward having a circular profile, the rider ends up traveling around the edge of the steed along a helical path. Voila: intrinsic angular momentum, AKA spin.

Sadly, this kind of spin isn’t quite like that we see in physical particles, because for Jellyfish instances it can only be aligned with the steed particle’s direction of motion. Nevertheless, by increasing the number of riders that the steed carries, you can build particles for which angular momentum comes in tidy discrete quantities. Use one rider and the momentum is always clockwise or anti-clockwise (-1 or 1). Use two riders and the momentum can be in one of three states, both anti-clockwise, both clockwise, or in opposite directions (-2, 0, 2). Use three and you get the following pattern: (-3, -1, 1, 3). This is the same pattern that we see for spin number in subatomic particles.

I should re-iterate a point here that I made last week. Nice though these apparent similarities between these discrete systems and physics are, they’re not illustrative of anything except potential. This work is still a long way from being physical science. Furthermore, the simulations are costly and still somewhat unreliable. The best video I have of particle spin is here:
http://www.youtube.com/watch?v=gsCwILrSuBM

As you can see, at this scale, the rider has a tendency to flip direction from time to time, reversing the particle’s spin. Clearly much larger simulations are needed to test what this approach is truly capable of.

Nevertheless, the doors seem to be wide open to further experimentation. For instance, by creating riders that only travel in packs of a certain size, you can build particles with flavors that obey the properties of mathematical groups. That could be useful further down the line if we get as far as trying to emulate the Standard Model. In short, there seems to be plenty of fun work to do here and I’ve barely scratched the surface.

If you’d like to see a preprint of the paper I submitted to the JOUAL proceedings, just let me know. Or, if you’d like to see some open-source code for building this kind of simulation, that can be arranged. If you’re at all intrigued by these kind of simulations, I encourage you to try them out for yourself. There’s a world of fascinating science out there waiting to happen, and a lot of it can be discovered right there in your living-room.

It’s important to say upfront that the research I’ve been doing is not physics. At least not yet. I don’t have a grand theory for how the universe works, and I’m not trying to advertise one. What I’m trying to do instead is make a point about tools.

Physics is founded on Calculus and continuum mathematics because they are tools that deliver results. They have delivered more concrete progress than any other modeling system that the human race has ever developed. However, now they are failing. The standard model was presented in its current form in 1974. Relativity and Quantum Mechanics have resisted integration since around 1905. Thus, the most important frontier in physics has yielded only limited progress in the last hundred years, and virtually none in the last forty. String Theory, while terribly grand and clever, is so amorphous that it predicts ten to the five hundred different possible sets of physical laws and has no predictive power to speak of. In my opinion, this is because the tools in use are reaching the limits of their applicability.

Nevertheless, we cannot expect physicists to believe this, or to change the tools they use, because at this point, swapping to any other modeling system entails a massive step backwards. This step is one that only a few very brave souls are willing to take. (Frankly, they’re braver than me because I’m not a career physicist and I have nothing to lose.) Therefore, it’s very likely up to someone else–someone outside the physics community–to start producing tools that can do what continuum mathematics cannot.

The first, most important part of this task, IMO, is catching up with the last three hundred years of scientific progress. As is hopefully clear from this blog, the tools that I believe will help are those that have been developed in Computer Science. The goal then is the replication of the total set of observed symmetries of nature in a discrete, iterative system that is no more complex than strictly necessary. This includes rotational and Lorentz invariance, the wave properties of Quantum Mechanical systems that are customarily modeled through the use of Hilbert Spaces, and everything else. This includes all those symmetries employed by Gauge Theory such as SU3, if such things prove necessary under the new system. Physics hinges on symmetry. Once the symmetries can be painlessly reproduced, things will go more smoothly.

The easiest place to start seemed to me to be rotational invariance, and this is what my first paper was about. The aim was to produce a discrete medium and an iterative function that could be applied to the elements of that medium that would produce a pattern that moved equally well in all directions. For those of you familiar with Cellular Automata (CAs), the goal, if you like, was to produce a universal glider that could travel equally well in any direction, rather than just in diagonal lines. The difficulty here is that discrete systems have a limited number of degrees of freedom. That makes travel in more directions than you have degrees of freedom a challenge.

Various systems have been tried to produce such a universal glider. One such system is to use a grid as the discrete medium and to define a glider with motion described by some number of steps along each axis with each turn. For instance, to go North North East, the glider might take three steps North for every step East. One problem with this approach is that to change direction just a small amount can require enormous changes in the ratios of motion along each axis. Thus, in order to produce motion in all directions, the glider needs an effectively infinite memory in which to store what part of its movement cycle it’s in at any time, along with a mechanism for converting between axis ratios when a change in direction is required.

Another problem is that this model has trouble compensating for the kind of spatial distortion witnessed in Relativistic systems. Specifically: there’s no room in the model for spatial expansion or contraction. That means no Big Bang, at least, not one that’s compatible with cosmological observations. Ideally, we’d like to choose a model that rules out none of the kinds of behavior we’d like to later produce.

Another approach that’s been explored is to once again use a grid, but to have the glider change axis of motion with each step based on some probability function. Thus when headed NNE, this glider has a 75% likelihood of going North, and a 25% likelihood of going East, but we don’t know which way it’ll turn for each step. While this approach gets around the problem of the awkward issue of ratios on different axes, it replaces it with dependency on a continuously varying probability value. Such variables are exactly the kind of tools we’d like to avoid using. Furthermore, the use of a grid once again rules out large chunks of Relativity.

What I do instead is use a densely-connected, irregular graph as my discrete medium, and define my glider as a function operating over sets of nodes on that graph. I define two sets, front nodes and back nodes, if you like, and then employ a simple algorithm I call ‘Jellyfish’ to find a new set of front nodes with each iteration.

The formula for Jellyifish is outlined in my NKS Midwest 2008 presentation slides, which you can find here:
http://www.cs.indiana.edu/%7Edgerman/2008midwestNKSconference/Lamb_Slides.pdf
The slides outline the formula, so I won’t duplicate it here.

If you want a more in depth explanation, my paper on this system will be published in the journal Complex Systems shortly, but if you don’t want to wait, send me your email address and I’ll send you a preprint. Alternatively, if you’d just like to see the results, you can alway go to YouTube and watch the glider, or ‘pseudo-particle’ moving for yourself.
You can find it here:
http://www.youtube.com/user/alexlamb#p/u/8/Y_yCxcjYPmo

Using an irregular graph means that the bulk properties of the medium are the same in every direction. There are no preferred directions of motion, so most of the anisotropy problems associated with Cellular Automata disappear immediately. Furthermore, the medium can be distorted in any way we like. Its geometry is not fixed. This means that nothing is stopping us from exploring the implications of Relativity later. Defining a pseudo-particle in terms of operations over sets of nodes also allows us to define orientation of motion as a group effect, and thus to describe motion over an arbitrarily large number of directions with ease.

To some, the Irregular Graph/Jellyfish approach feels rather more random than Cellular Automata, more fundamentally complex, and certainly less likely to produce pretty patterns. However, though we lose a little in terms of algorithmic succinctness, we seem to gain at least as much in terms of descriptive power, and, as you’ll hopefully see in later posts, what we gain often looks eerily like physics.

The Jellyfish algorithm works equally well in 2, 3 or any dimensionality, as well as on curved surfaces. It shows potential compatibility with Lorentz invariance, as I illustrate in the slides, and even some properties similar to those of Quantum Mechanical systems. What Jellyfish doesn’t have is wavelength, polarization, or the habit of following all paths at once. It’s a long way from being a physical particle, and that’s okay because it’s not supposed to be one. However, what it does demonstrate is that getting something like basic particle behavior out of a discrete system is extremely easy. Natural, even.

I believe that this work work leaves us with a new class of automata to explore, and an important question to answer: What is the simplest algorithmic model that fulfills the constraints that physical law imposes on a system, without resorting to the classical formalism of that system. In other words, if we tie one hand behind our back, and forgo the use of differential equations, axes, and smooth numbers, can we still wield the rapier of science? I bet we can. In solving this and similar puzzles, we may be opening the doors to a new era of science. The answers are just a few simple experiments away and anyone with a computer and a little curiosity can start looking.