Riviera Blog

Is our universe just a lab experiment, possibly running as a gigantic computer simulation? Recent developments in philosophy, computer science and quantum theory have made people ask themselves the question again, reinjecting substance into the old brain-in-a-vat thought experiment (which goes: “I cannot prove that I’m not just a brain floating in a jar, receiving various electrical impulses through electrodes, making me believe I’m living in this world, but which in fact doesn’t exist”).

The first new development is a logical argument, introduced by Nick Bostrom in 2003. The so-called Simulation Argument considers the following proposition: a sufficiently advanced civilisation has the required knowledge to run computer simulations of virtual universes, within which agents believe they are “first-order” beings, and not just a piece of software.

If that proposition is false, the reason is among three: civilisations never reach the stage when they to run virtual universes, either because they go extinct first, or because they don’t run them for some reason, probably ethical, or because such simulations are impossible.

On the other hand, if the proposition is true then it’s likely that such civilisations are, right now, running many of those simulations. As a consequence there must be more simulated worlds than real ones, which means that it is likely that our own universe is itself a simulation. The paradigm created by the consequences of that particular conclusion is called simulism.

In any case, all possible conclusions of whether the proposition is true or false are rather mind boggling. But one interesting thing about digital simulism is that it seems more testable than the more general brain-in-a-jar concept. For instance, IA skeptics may eventually manage to prove that it is impossible to digitally simulate our brains. Reciprocally, if we ever managed to run universal computer simulations, it would definitely move the odds toward the hypothesis that we are in a such a simulation. Or perhaps we could find “artefacts” which we know, through our knowledge of computers, are signs that the world in which we live is digital, which would also change the odds (while never proving anything for certain). Such artefacts could take the form of a “window” popping up in front of you with the text “YOU ARE LIVING IN A COMPUTER SIMULATION”, to use an example of Bolstrom’s. They could also be “bugs”, like Trinity’s explanation of Déja Vu in The Matrix. But more interestingly they could also be found in the very fabric of our universe, namely the laws of physics.

(coming soon: part 2 — the universe as a quantum computer)

[tags]simulism, brain in a vat, simulation argument[/tags]

Pictures from the November 2006 W3C AC meeting in Tokyo

[tags]Japan, pictures, W3C[/tags]

I had this idea in my head for a while: all the graph visualisations you see on the web these days (social networks, topics, tags, etc.), reminded me of Tamara Munzer’s work from a few years back, on using hyperbolic geometry to display graphs so that you always see the whole graph, whatever part you’re looking at. Put it simply, hyperbolic projections give an impression that you’re looking at objects through a magnifying glass (see figure, left). And that’s what Escher was showing in his “Circle Limit” series (right).

Somehow it crossed my mind to do an interactive version in SVG, so I wrote some code for it, and then forgot about it for lack of real uses. Then I read Designing for Small Screens, a book on UI design, which discusses how to display as much information as possible on phone or PDA screens. One particular method it shows is the magnifying glass effect:

Using hyperbolic projections to produce this kind of lens effect is one way to show geometric information on a reduced space, but it has its drawbacks: the geometry of the objects is warped, which can be confusing. Also, not all the screen’s area is used, which somewhat defeats the purpose.

However there is a better solution. When I started to implement the hyperbolic projections, I came across old friends of mine from university: quadric surfaces, which led me to find a way to fix both problems. Section 2 explains the gory details. By modifying the projection formula, one can add a parameter that makes the magnifying glass effect more squarish and flatish, and thus makes the display a bit more friendly than by using the default projection.

Left: default projection, middle and right: flatter projection

This works particularly well with grid displays like calendars:

or command navigations:

SVG sources: grid, calendar, menu. ECMAScript code for the projection and the interactive panning.
The Gory Details

The two examples showed in the figures at the beginning actually use the Pointcaré disc model, which preserves angles but distorts lines into circular arcs (as shown on the figure 1). That distortion can be confusing for grid displays like calendars, although it might work for graphs. So instead I went for the Klein disc model, which preserves lines but not angles. The figure below show how it works in one dimension.

The observer is located at the origin (O) and looks up in the z direction. The original objects are located on plane s (i.e. the screen). First, each point (yellow circle) is projected onto a hyperbola (red line) and becomes the blue circle. Then the point is projected back onto s using a standard perspective projective. The effect is exactly as if the observer was looking at the objects laid out on the hyperboloid. This shows graphically how all the points of the hyperboloid are visible, as they are projected into a finite interval of s.

In 2 dimensions, s is now a plane (i.e. the screen) and the hyperbole becomes a hyperboloid of 2 sheets:

The hyperboloid’s algebraic equation is:

• x²+y²-z²=-1

The combined projections above yield the following formula:

• x’ = x / sqrt(x² + y²)
• y’ = y / sqrt(y² + y²)

Now, in order to go “flatter and squarer”, the hyperboloid needs to go “super”:

• xⁿ+yⁿ-zⁿ=-1

where n is any even positive integer. The greater n is, the squarer/flatter the surface. The red hyperbole becomes all squashed on s, and in 2D, the surface is now a super hyperboloid and looks like:

A super hyperboloid is one particular type of superquadric, a superset of quadrics surfaces with nice properties. See Barr, A.H., Superquadrics and Angle-Preserving Transformations, IEEE CGA, No. 1, January 1981, pp. 11-23.

The projection formulas become:

• x’ = x / nsqrt(n, xⁿ + yⁿ)
• y’ = y / nsqrt(n, yⁿ + yⁿ)

and our objects now look like the images above showed.

Of course, all those exponentiations and roots take a while to compute, so the practicality of the whole thing remains to be demonstrated. The code could also support for more primitives and tree transforms (actually, the code did support transforms, but bugs in SVG renderers made me remove it), but that is left to the reader.