Last week it was 34 years since the original launch of Mathematica and whatâs now the Wolfram Language. And through all those years weâve energetically continued building further and further, adding ever more capabilities, and steadily extending the domain of the computational paradigm.
In recent years weâve established something of a rhythm, delivering the fruits of our development efforts roughly twice a year. We released Version 13.0 on December 13, 2021. And now, roughly six months later, weâre releasing Version 13.1. As usual, even though itâs a â.1â release, itâs got a lot of new (and updated) functionality, some of which weâve worked on for many years but finally now brought to fruition.
For me itâs always exciting to see what we manage to deliver in each new version. And in Version 13.1 we have 90 completely new functionsâas well as 203 existing functions with substantial updates. And beyond what appears in specific functions, thereâs also major new functionality in Version 13.1 in areas like user interfaces and the compiler.
The Wolfram Language as it exists today encompasses a vast range of functionality. But its great power comes not just from what it contains, but also from how coherently everything in it fits together. And for nearly 36 years Iâve taken it as a personal responsibility to ensure that that coherence is maintained. Itâs taken both great focus and lots of deep intellectual work. But as I experience them every day in my use of the Wolfram Language, Iâm proud of the results.
And for the past four years Iâve been sharing the âbehind the scenesâ of how itâs achievedâby livestreaming our Wolfram Language design review meetings. Itâs an unprecedented level of opennessâand engagement with the community. In designing Version 13.1 weâve done 90 livestreamsâlasting more than 96 hours. And in opening up our process weâre providing visibility not only into what was built for Version 13.1, but also of why it was built, and how decisions about it were made.
But, OK, so what finally is in Version 13.1? Letâs talk about some highlights….
From the very beginning of Mathematica and the Wolfram Language weâve had the concept of listability: if you add two lists, for example, their corresponding elements will be added:
✕

Itâs a very convenient mechanism, that typically does exactly what youâd want. And for 35 years we havenât really considered extending it. But if we look at code that gets written, it often happens that there are parts that basically implement something very much like listability, but slightly more general. And in Version 13.1 we have a new symbolic construct, Threaded, that effectively allows you to easily generalize listability.
Consider:
✕

This uses ordinary listability, effectively computing:
✕

But what if you want instead to âgo down a levelâ and thread {x,y} into the lowest parts of the first list? Well, now you can use Threaded to do that:
✕

On its own, Threaded is just a symbolic wrapper:
✕

But as soon as it appears in a functionâlike Plusâthat has attribute Listable, it specifies that the listability should be applied after whatâs specified inside Threaded is âthreadedâ at the lowest level.
Hereâs another example. Create a list:
✕

How should we then multiply each element by {1,â1}? We could do this with:
✕

But now weâve got Threaded, and so instead we can just say:
✕

You can give Threaded as an argument to any listable function, not just Plus and Times:
✕

You can use Threaded and ordinary listability together:
✕

You can have several Threadeds together as well:
✕

Threaded, by the way, gets its name from the function Thread, which explicitly does âthreadingâ, as in:
✕

By default, Threaded will always thread into the lowest level of a list:
✕

✕

Hereâs a âreallifeâ example of using Threaded like this. The data in a 3D color image consists of a rank3 array of triples of RGB values:
✕

This multiplies every RGB triple by {0,1,2}:
✕

Most of the time you either want to use ordinary listability that operates at the top level of a list, or you want to use the default form of Threaded, that operates at the lowest level of a list. But Threaded has a more general form, in which you can explicitly say what level you want it to operate at.
Hereâs the default case:
✕

Hereâs level 1, which is just like ordinary listability:
✕

And hereâs threading into level 2:
✕

Threaded provides a very convenient way to do all sorts of arraycombining operations. Thereâs additional complexity when the object being âthreaded inâ itself has multiple levels. The default in this case is to align the lowest level in the thing being threaded in with the lowest level of the thing into which itâs being threaded:
✕

Here now is âordinary listabilityâ behavior:
✕

For the arrays weâre looking at here, the default behavior is equivalent to:
✕

Sometimes itâs clearer to write this out in a form like
✕

which says that the first level of the array inside the Threaded is to be aligned with the second level of the outside array. In general, the default case is equivalent to â1 â â1, specifying that the bottom level of the array inside the Threaded should be aligned with the bottom level of the array outside.
In every version of the Wolfram Language we try to add new functions that will make general programs easier to write and easier to read. In Version 13.1 the most important such function is Threaded. But there are quite a few others as well.
First in our collection for Version 13.1 is DeleteElements, which deletes specified elements from a list. Itâs like Complement, except that it doesnât reorder the list (analogous to the way DeleteDuplicates removes duplicate elements, without reordering in the way that Union does):
✕

DeleteElements also allows more detailed control of how many copies of an element can be deleted. Here it is up to 2 bâs and 3 câs:
✕

Talking of DeleteDuplicates, another new function in Version 13.1 is DeleteAdjacentDuplicates:
✕

Weâve had Union, Intersection and Complement since Version 1.0. In Version 13.1 weâre adding SymmetricDifference: find elements that (in the 2argument case) are in one list or the other, but not both. For example, what countries are in the G20 or the EU, but not both?
✕

Letâs say you have several lists, and you want to know what elements are unique to just one of these lists, and donât occur in multiple lists. The new UniqueElements tells one.
As an example, this tells us which letters uniquely occur in various alphabets:
✕

Weâve had Map and Apply, with short forms /@ and @@, ever since Version 1.0. In Version 4.0 we added @@@ to represent Apply[f,expr,1]. But we never added a separate function to correspond to @@@. And over the years, thereâve been quite a few occasions where Iâve basically wanted, for example, to do something like âFold[@@@, ...]â. Obviously Fold[Apply[#1,#2,1]&,...] would work. But it feels as if thereâs a âmissingâ named function. Well, in Version 13.1, we added it: MapApply is equivalent to @@@:
✕

Another small convenience added in Version 13.1 is SameAsâessentially an operator form of SameQ. Why is such a construct needed? Well, there are always tradeoffs in language design. And back in Version 1.0 we decided to make SameQ work with any number of arguments (so you can test whether a whole sequence of things are the same). But this means that for consistency SameQ[expr] must always return Trueâso itâs not available as an operator of SameQ. And thatâs why now in Version 13.1 weâre adding SameAs, that joins the family of operatorform functions like EqualTo and GreaterThan:
✕

Procedural programmingâoften with âvariables hanging outââisnât the preferred style for most Wolfram Language code. But sometimes itâs the most convenient way to do things. And in Version 13.1 weâve add a small piece of streamlining by introducing the function Until. Ever since Version 1.0 weâve had While[test,body] which repeatedly evaluates body while test is True. But if test isnât True even at first, While wonât ever evaluate body. Until[test,body] does things the other way around: it evaluates body until test becomes True. So if test isnât True at first, Until will still evaluate body once, in effect only looking at the test after itâs evaluated the body.
Last but not least in the list of new core language functions in Version 13.1 is ReplaceAt. Replace attempts to apply a replacement rule to a complete expressionâor a whole level in an expression. ReplaceAll (/.) does the same thing for all subparts of an expression. But quite often one wants more control over where replacements are done. And thatâs what ReplaceAt provides:
✕

An important feature is that it also has an operator form:
✕

Why is this important? The answer is that it gives a symbolic way to specify not just what replacement is made, but also where it is made. And for example this is whatâs needed in specifying steps in proofs, say as generated by FindEquationalProof.
What is a character? Back when Version 1.0 was released, characters were represented as 8bit objects: usually ASCII, but you could pick another âcharacter encodingâ (hence the ChararacterEncoding option) if you wanted. Then in the early 1990s came Unicodeâwhich we were one of the very first companies to support. Now âcharactersâ could be 16bit constructs, with nearly 65,536 possible âglyphsâ allocated across different languages and uses (including some mathematical symbols that we introduced). Back in the early 1990s Unicode was a newfangled thing, that operating systems didnât yet have builtin support for. But we were betting on Unicode, and so we built our own infrastructure for handling it.
Thirty years later Unicode is indeed the universal standard for representing characterlike things. But somewhere along the way, it turned out the world needed more than 16 bitsâ worth of characterlike things. At first it was about supporting variants and historical writing systems (think: cuneiform or Linear B). But then came emoji. And it became clear thatâyes, arguably in a return to the Egyptian hieroglyph style of communicationâthere was an almost infinite number of possible pictorial emoji that could be made, each of them being encoded as their own Unicode code point.
Itâs been a slow expansion. Original 16bit Unicode is âplane 0â. Now there are up to 16 additional planes. Not quite 32bit characters, but given the way computers work, the approach now is to allow characters to be represented by 32bit objects. Itâs far from trivial to do that uniformly and efficiently. And for us itâs been a long process to upgrade everything in our systemâfrom string manipulation to notebook renderingâto handle full 32bit characters. And thatâs finally been achieved in Version 13.1.
But thatâs far from all. In English weâre pretty much used to being able to treat text as a sequence of letters and other characters, with each character being separate. Things get a bit more complicated when you start to worry about diphthongs like ĂŠ. But if there are fairly few of these, it works to just introduce them as individual âUnicode charactersâ with their own code point. But there are plenty of languagesâlike Hindi or Khmerâwhere what appears in text like an individual character is really a composite of letterlike constructs, diacritical marks and other things. Such composite characters are normally represented as âgrapheme clustersâ: runs of Unicode code points. The rules for handling these things can be quite complicated. But after many years of development, major operating systems now successfully do it in most cases. And in Version 13.1 weâre able to make use of this to support such constructs in notebooks.
OK, so what does 32bit Unicode look like? Using CharacterRange (or FromCharacterCode) we can dive in and just see whatâs out there in âcharacter spaceâ. Hereâs part of ordinary 16bit Unicode space:
✕

Hereâs some of what happens in âplane1â above character code 65535, in this case catering to âlegacy computationsâ:
✕

Plane0 (below 65535) is pretty much all full. Above that, things are sparser. But around 128000, for example, there are lots of emoji:
✕

You can use these in the Wolfram Language, and in notebooks, just like any other characters. So, for example, you can have wolf and ram variables:
✕

The sorts before the because it happens to have a numerically smaller character code:
✕

In a notebook, you can enter emoji (and other Unicode characters) using standard operating system toolsâlike ctrlcmdspace on macOS:
✕

The world of emoji is rapidly evolvingâand that can sometimes lead to problems. Hereâs an emoji range that includes some very familiar emoji, but on at least one of my computer systems also includes emoji that display only as :
✕

The reason that happens is that my default fonts donât contain glyphs for those emoji. But all is not lost. In Version 13.1 weâre including a font from Twitter that aims to contain glyphs for pretty much all emoji:
✕

Beyond dealing with individual Unicode characters, thereâs also the matter of composites, and grapheme clusters. In Hindi, for example, two characters can combine into something thatâs rendered (and treated) as one:
✕

The first character here can stand on its own:
✕

But the second one is basically a modifier that extends the first character (in this particular case adding a vowel sound):
✕

But once the composite à€čà€ż has been formed it acts âtextuallyâ just like a single character, in the sense that, for example, the cursor moves through it in one step. When it appears âcomputationallyâ in a string, however, it can still be broken into its constituent Unicode elements:
✕

This kind of setup can be used not only for a language like Hindi but also for European languages that have diacritical marks like umlauts:
✕

Even though this looks like one characterâand in Version 13.1 itâs treated like that for âtextualâ purposes, for example in notebooksâit is ultimately made up of two distinct âUnicode charactersâ:
✕

In this particular case, though, this can be ânormalizedâ to a single character:
✕

It looks the same, but now it really is just one character:
✕

Hereâs a âcombined characterâ that you can form
✕

but for which thereâs no single character to which it normalizes:
✕

The concept of composite characters applies not only to ordinary text, but also to emojis. For example, take the emoji for a woman
✕

together with the emoji for a microscope
✕

and combine them with the âzerowidthjoinerâ character (which, needless to say, doesnât display as anything)
✕

and you get (yes, somewhat bizarrely) a woman scientist!
✕

Needless to say, you can do this computationallyâthough the âcalculusâ of whatâs been defined so far in Unicode is fairly bizarre:
✕

Iâm sort of hoping that the future of semantics doesnât end up being defined by the way emojis combine .
As one lastâarguably hackyâexample of combining characters, Unicode defines various âtwoletterâ combinations to be flags. Type then , and you get !
Once again, this can be made computational:
✕

(And, yes, itâs an interesting question what renders here, and what doesnât. In some operating systems, no flags are rendered, and we have to pull in a special font to do it.)
✕

It used to be that the only âspecial key sequenceâ one absolutely should know in order to use Wolfram Notebooks was shiftenter. But gradually there have started to be more and more highprofile operations that are conveniently done by âpressing a buttonâ. And rather than expecting people to remember all those special key sequences (or think to look in menus for them) weâve decided to introduce a toolbar that will be displayed by default in every standard notebook. Version 13.1 has the first iteration of this toolbar. Subsequent versions will support an increasing range of capabilities.
Itâs not been easy to design the default toolbar (and we hope youâll like what we came up with!) The main problem is that Wolfram Notebooks are very general, and there are a great many things you can do with themâwhich itâs challenging to organize into a manageable toolbar. (Some special types of notebooks have had their own specialized toolbars for a while, which were easier to design by virtue of their specialization.)
So whatâs in the toolbar? On the left are a couple of evaluation controls:
means âEvaluateâ, and is simply equivalent to pressing shiftret (as its tooltip says). means âAbortâ, and will stop a computation. To the right of is the menu shown above. The first part of the menu allows you to choose what will be evaluated. (Donât forget the extremely useful âEvaluate In Placeâ that lets you evaluate whatever code you have selectedâsay to turn RGBColor[1,0,0] in your input into .) The bottom part of the menu gives a couple of more detailed (but highly useful) evaluation controls.
Moving along the toolbar, we next have:
✕

If your cursor isnât already in a cell, the pulldown allows you to select what type of cell you want to insert (itâs similar to the âtongueâ that appears within the notebook). (If your cursor is already inside a cell, then like in a typical word processor, the pulldown will tell you the style thatâs being used, and let you reset it.)
gives you a little panel to control to appearance of cells, changing their background colors, frames, dingbats, etc.
Next come cellrelated buttons: . The first is for cell structure and grouping:
✕

copies input from above (cmdL). Itâs an operation that I, for one, end up doing all the time. Iâll have an input that I evaluate. Then Iâll want to make a modified version of the input to evaluate again, while keeping the original. So Iâll copy the input from above, edit the copy, and evaluate it again.
copies output from above. I donât find this quite as useful as copy input from above, but it can be helpful if you want to edit output for subsequent input, while leaving the âactual outputâ unchanged.
The block is all about content in cells. (which youâll often press repeatedly) is for extending a selectionâin effect going ever upwards in an expression tree. (You can get the same effect by pressing ctrl. or by multiclicking, but itâs a lot more convenient to repeatedly press a single button than to have to precisely time your multiclicks.)
is the singlebutton way to get ctrl= for entering natural language input:
✕

iconizes your selection:
✕

Iconization is something we introduced in Version 11.3, and itâs something thatâs proved incredibly useful, particularly for making code easy to read (say by iconizing details of options). (You can also iconize a selection from the rightclick menu, or with ctrlcmd'.)
is most relevant for code, and toggles commenting (with ) a selection. brings up a palette for math typesetting. lets you enter that will be converted to Wolfram Language math typesetting. brings up a drawing canvas. inserts a hyperlink (cmdshiftH).
If youâre in a text cell, the toolbar will look different, now sporting a text formatting control:
Most of this is fairly standard. lets you insert âcode voiceâ material. and are still in the toolbar for inserting math into a text cell.
On the righthand end of the toolbar are three more buttons: . gives you a dialog to publish your notebook to the cloud. opens documentation, either specifically looking up whatever you have selected in the notebook, or opening the front page (âroot guide pageâ) of the main Wolfram Language documentation. Finally, lets you search in your current notebook.
As I mentioned above, whatâs in Version 13.1 is just the first iteration of our default toolbar. Expect more features in later versions. One thing thatâs notable about the toolbar in general is that itâs 100% implemented in Wolfram Language. And in addition to adding a great deal of flexibility, this also means that the toolbar immediately works on all platforms. (By the way, if you donât want the toolbar in a particular notebookâor for all your notebooksâjust rightclick the background of the toolbar to pick that option.)
We first introduced Wolfram Notebooks with Version 1.0 of Mathematica, in 1988. And ever since then, weâve been progressively polishing the notebook interface, doing more with every new version.
The ctrl= mechanism for entering natural language (âWolframAlphastyleâ) input debuted in Version 10.0âand in Version 13.1 itâs now accessible from the button in the new default notebook toolbar. But what actually is when itâs in a notebook? In the past, itâs been a fairly complex symbolic structure mainly suitable for evaluation. But in Version 13.1 weâve made it much simpler. And while that doesnât have any direct effect if youâre just using purely in a notebook, it does have an effect if you copy into another application, like puretext email. In the past this produced something that would work if pasted back into a notebook, but definitely wasnât particularly readable. In Version 13.1, itâs now simply the Wolfram Language interpretation of your natural language input:
✕

What happens if the computation you do in a notebook generates a huge output? Ever since Version 6.0 weâve had some form of âoutput limiterâ, but in Version 13.1 itâs become much sleeker and more useful. Hereâs a typical example:
✕

Talking of big outputs (as well as other things that keep the notebook interface busy), another change in Version 13.1 is the new asynchronous progress overlay on macOS. This doesnât affect other platforms where this problem had already been solved, but on the Mac changes in the OS had led to a situation where the notebook front end could mysteriously pop to the front on your desktopâa situation that has now been resolved.
One of the slightly unusual user interface features thatâs existed ever since Version 1.0 is the Why the Beep? menu itemâthat lets you get an explanation of any âerror beepâ that occurs while youâre running the system. The function Beep lets you generate your own beep. And now in Version 13.1 you can use Beep["string"] to set up an explanation of âyour beepâ, that users can retrieve through the Why the Beep? menu item.
The basic notebook user interface works as much as possible with standard interface elements on all platforms, so that when these elements are updated, we always automatically get the âmost modernâ look. But there are parts of the notebook interface that are quite special to Wolfram Notebooks and are always custom designed. One that hadnât been updated for a while is the Preferences dialogâwhich now in Version 13.1 gets a full makeover:
✕

When you tell the Wolfram Language to do something, it normally just goes off and does it, without asking you anything (well, unless it explicitly needs input, needs a password, etc.) But what if thereâs something that it might be a good idea to do, though itâs not strictly necessary? What should the user interface for this be? Itâs tricky, but I think we now have a good solution that weâve started deploying in Version 13.1.
In particular, in Version 13.1, thereâs an example related to the Wolfram Function Repository. Say you use a function for which an update is available. What now happens is that a blue box is generated that tells you about the updateâthough it still keeps going with the computation, ignoring the update:
✕

If you click the Update Now button in the blue box you can do the update. And then the point is that you can run the computation again (for example, just by pressing shiftenter), and now itâll use the update. In a sense the core idea is to have an interface where there are potentially multiple passes, and where a computation always runs to completion, but you have an easy way to change how itâs set up, and then run it again.
One of the great things about the Wolfram Language is that it works well for programs of any scaleâfrom less than a line long to millions of lines long. And for the past several years weâve been working on expanding our support for very large Wolfram Language programs. Using LSP (Language Server Protocol) weâve provided the capability for most standard external IDEs to automatically do syntax coloring and other customizations for the Wolfram Language.
In Version 13.1 weâre also adding a couple of features that make largescale code editing in notebooks more convenient. The firstâand widely requestedâis block indent and outdent of code. Select the lines you want to indent or outdent and simply press tab or shifttab to indent or outdent them:
✕

Ever since Version 6.0 weâve had the ability to work with .wl package files (as well as .wls script files) using our notebook editing system. A new default feature in Version 13.1 is numbering of all code lines that appear in the underlying file (and, yes, we correctly align line numbers accounting for the presence of noncode cells):
✕

So now, for example, if you get a syntax error from Get or a related function, youâll immediately be able to use the line number it reports to find where it occurs in the underlying file.
In Version 12.2 we introduced Canvas as a convenient interface for interactive drawing in notebooks. In Version 13.1 weâre introducing the notion of toggling a canvas on top of any cell.
Given a cell, just select it and press , and youâll get a canvas:
✕

Now you can use the drawing tools in the canvas to create an annotation overlay:
✕

If you evaluate the cell, the overlay will stay. (You can get rid of the âcanvas wrapperâ by applying Normal.)
In Version 12.3 we introduced Tree as a new fundamental construct in the Wolfram Language. In Version 13.0 we added a variety of styling options for trees, and in Version 13.1 weâre adding more styling as well as a variety of new fundamental features.
An important update to the fundamental Tree construct in Version 13.1 is the ability to name branches at each node, by giving them in an association:
✕

All tree functions now include support for associations:
✕

In many uses of trees the labels of nodes are crucial. But particularly in more abstract applications one often wants to deal with unlabeled trees. In Version 13.1 the function UnlabeledTree (roughly analogously to UndirectedGraph) takes a labeled tree, and basically removes all visible labels. Here is a standard labeled tree
✕

and hereâs the unlabeled analog:
✕

In Version 12.3 we introduced ExpressionTree for deriving trees from general symbolic expressions. Our plan is to have a wide range of âspecial treesâ appropriate for representing different specific kinds of symbolic expressions. Weâre beginning this process in Version 13.1 by, for example, having the concept of âDataset treesâ. Hereâs ExpressionTree converting a dataset to a tree:
✕

And now hereâs TreeExpression âinvertingâ that, and producing a dataset:
✕

(Remember the convention that *Tree functions return a tree; while Tree* functions take a tree and return something else.)
Hereâs a âgraph renderingâ of a more complicated dataset tree:
✕

The new function TreeLeafCount lets you count the total number of leaf nodes on a tree (basically the analog of LeafCount for a general symbolic expression):
✕

Another new function in Version 13.1 thatâs often useful in getting a sense of the structure of a tree without inspecting every node is RootTree. Hereâs a random tree:
✕

RootTree can get a subtree thatâs âclose to the rootâ:
✕

It can also get a subtree thatâs âfar from the leavesâ, in this case going down to elements that are at level â2 in the tree:
✕

In some ways the styling of trees is like the styling of graphsâthough there are some significant differences as a result of the hierarchical nature of trees. By default, options inserted into a particular tree element affect only that tree element:
✕

But you can give rules that specify how elements in the subtree below that element are affected:
✕

In Version 13.1 there is now detailed control available for styling both nodes and edges in the tree. Hereâs an example that gives styling for parent edges of nodes:
✕

Options like TreeElementStyle determine styling from the positions of elements. TreeElementStyleFunction, on the other hand, determines styling by applying a function to the data at each node:
✕

This uses both data and position information for each node:
✕

In analogy with VertexShapeFunction for graphs, TreeElementShapeFunction provides a general mechanism to specify how nodes of a tree should be rendered. This named setting for TreeElementShapeFunction makes every node be displayed as a circle:
✕

We first introduced dates into Wolfram Language in Version 2.0, and we introduced modern date objects in Version 10.0. But to really make dates fully computable, there are many detailed cases to consider. And in Version 13.1 weâre dealing with yet another of them. Letâs say youâve got the date January 31, 2022. What date is one month laterâgiven that thereâs no February 31, 2022?
If we define a month âphysicallyâ, it corresponds to a certain fractional number of days:
✕

And, yes, we can use this to decide what is a month after January 31, 2022:
✕

Slightly confusing here is that weâre dealing with date objects of âdayâ granularity. We can see more if we go down to the level of minutes:
✕

If oneâs doing something like astronomy, this kind of âphysicalâ date computation is probably what one wants. But if oneâs doing everyday âhumanâ activities, itâs almost certainly not what one wants; instead, one wants to land on some calendar date or another.
Hereâs the default in the Wolfram Language:
✕

But now in Version 13.1 we can parametrize more precisely what we want. This default is what we call "RollBackward": wherever we âlandâ by doing the raw date computation, we âroll backwardâ to the first valid date. An alternative is "RollForward":
✕

Whatever method one uses, there are going to be weird cases. Letâs say we start with several consecutive dates:
✕

With "RollBackward" we have the weirdness of repeating February 28:
✕

With "RollForward" we have the weirdness of repeating March 1:
✕

Is there any alternative? Yes, we can use "RollOver":
✕

This keeps advancing through days, but then has the weirdness that it goes backwards. And, yes, thereâs no âright answerâ here. But in Version 13.1 you can now specify exactly what you want the behavior to be.
The same issue arises not just for months, but also, for example, for years. And it affects not just DatePlus, but also DateDifference.
Itâs worth mentioning that in Version 13.1, in addition to dealing with the detail weâve just discussed, the whole framework for doing âdate arithmeticâ in Wolfram Language has been made vastly more efficient, sometimes by factors of hundreds.
Weâve had ImageCapture since Version 8.0 (in 2010) and AudioCapture since Version 11.1 (in 2017). Now in Version 13.1 we have VideoCapture. By default VideoCapture[] gives you a GUI that lets you record from your camera:
✕

Clicking the down arrow opens up a preview window that shows your current video:
✕

When youâve finished recording, VideoCapture returns the Video object you created:
✕
VideoCapture[] 
Now you can process or analyze this Video object just like you would any other:
✕

VideoCapture[] is a blocking operation that waits until youâve finished recording, then returns a result. But VideoCapture can also be used âindirectlyâ as a dynamic control. Thus, for example
✕

lets you asynchronously start and stop recording, even as you do other things in your Wolfram Language session. But every time you stop recording, the value of video is updated.
VideoCapture records video from your camera (and you can use the ImageDevice option to specify which one if you have several). VideoScreenCapture, on the other hand, records from your computer screenâin effect providing a video analog of CurrentScreenImage.
VideoScreenCapture[], like VideoCapture[], is a blocking operation as far as the Wolfram Language is concerned. But if you want to watch something happening in another application (say, a web browser), itâll do just fine. And in addition, you can give a screen rectangle to capture a particular region on your screen:
✕
VideoScreenCapture[{{0, 50}, {640, 498}}] 
Then for example you can analyze the time series of RGB color levels in the video thatâs produced:
✕

What if you want to screen record from a notebook? Well, then you can use the asynchronous dynamic recording mechanism that exists in VideoScreenCapture just as it does in VideoCapture.
By the way, both VideoCapture and VideoScreenCapture by default capture audio. You can switch off audio recording either from the GUI, or with the option AudioInputDeviceâNone.
If you want to get fancy, you can screen record a notebook in which you are capturing video from your camera (which in turn shows you capturing a video, etc.):
✕
VideoScreenCapture[EvaluationNotebook[]] 
In addition to capturing video from realtime goingson, you can also generate video directly from functions like AnimationVideo and SlideShowVideoâas well as by âtouringâ an image using TourVideo. In Version 13.1 there are some significant enhancements to TourVideo.
Take an animal scene and extract bounding boxes for elephants and zebras:
✕

Now you can make a tour video that visits each animal:
✕


Define a path function of a variable t:
✕

✕

Now we can use the path function to make a âspirallingâ tour video:


Transforming college calculus was one of the early achievements of Mathematica. But even now weâre continuing to add functionality to make college calculus ever easier and smoother to doâand more immediately connectable to applications. Weâve always had the function D for taking derivatives at a point. Now in Version 13.1 weâre adding ImplicitD for finding implicit derivatives.
So, for example, it can find the derivative of x^{y} with respect to x, with y determined implicit by the constraint x^{2} + y^{2} = 1:
✕

Leave out the first argument and youâll get the standard college calculus âfind the slope of the tangent line to a curveâ:
✕

So far all of this is a fairly straightforward repackaging of our longstanding calculus functionality. And indeed these kinds of implicit derivatives have been available for a long time in WolframAlpha. But for Mathematica and the Wolfram Language we want everything to be as general as possibleâand to support the kinds of things that show up in differential geometry, and in things like asymptotics and validation of implicit solutions to differential equations. So in addition to ordinary collegelevel calculus, ImplicitD can do things like finding a second implicit derivative on a curve defined by the intersection of two surfaces:
✕

In Mathematica and the Wolfram Language Integrate is a function that just gets you answers. (In WolframAlpha you can ask for a stepbystep solution too.) But particularly for educational purposesâand sometimes also when pushing boundaries of whatâs possibleâit can be useful to do integrals in steps. And so in Version 13.1 weâve added the function IntegrateChangeVariables for changing variables in integrals.
An immediate issue is that when you specify an integral with Integrate[...], Integrate will just go ahead and do the integral:
✕

But for IntegrateChangeVariables you need an âundoneâ integral. And you can get this using Inactive, as in:
✕

And given this inactive form, we can use IntegrateChangeVariables to do a âtrig substitutionâ:
✕

The result is again an inactive form, now stating the integral differently. Activate goes ahead and actually does the integral:
✕

IntegrateChangeVariables can deal with multiple integrals as wellâand with named coordinate systems. Here itâs transforming a double integral to polar coordinates:
✕

Although the basic âstructuralâ transformation of variables in integrals is quite straightforward, the whole story of IntegrateChangeVariables is considerably more complicated. âCollegelevelâ changes of variables are usually carefully arranged to come out easily. But in the more general case, IntegrateChangeVariables ends up having to do nontrivial transformations of geometric regions, difficult simplifications of integrands subject to certain constraints, and so on.
In addition to changing variables in integrals, Version 13.1 also introduces DSolveChangeVariables for changing variables in differential equations. Here itâs transforming the Laplace equation to polar coordinates:
✕

Sometimes a change of variables can just be a convenience. But sometimes (think General Relativity) it can lead one to a whole different view of a system. Here, for example, an exponential transformation converts the usual CauchyâEuler equation to a form with constant coefficients:
✕

The first derivative of x^{2} is 2x; the second derivative is 2. But what is the derivative? Itâs a question that was asked (for example by Leibniz) even in the first years of calculus. And by the 1800s Riemann and Liouville had given an answerâwhich in Version 13.1 can now be computed by the new FractionalD:
✕

And, yes, do another derivative and you get back the 1^{st} derivative:
✕

In the more general case we have:
✕

And this works even for negative derivatives, so that, for example, the (â1)^{st} derivative is an ordinary integral:
✕

It can be at least as difficult to compute a fractional derivative as an integral. But FractionalD can still often do it
✕

though the result can quickly become quite complicated:
✕

Why is FractionalD a separate function, rather than just being part of a generalization of D? We discussed this for quite a while. And the reason we introduced the explicit FractionalD is that there isnât a unique definition of fractional derivatives. In fact, in Version 13.1 we also support the Caputo fractional derivative (or differintegral) CaputoD.
For the derivative of x^{2}, the answer is still the same:
✕

But as soon as a function isnât zero at x = 0 the answer can be different:
✕

CaputoD is a particularly convenient definition of fractional differentiation when oneâs dealing with Laplace transforms and differential equations. And in Version 13.1 we can now only compute CaputoD but also do integral transforms and solve equations that involve it.
Hereâs a order differential equation
✕

and a order one
✕

as well as a π^{th}order one:
✕

Note the appearance of MittagLefflerE. This function (which we introduced in Version 9.0) plays the same kind of role for fractional derivatives that Exp plays for ordinary derivatives.
In February 1990 an internal bug report was filed against the stillindevelopment Version 2.0 of Mathematica:
✕

Itâs taken a long time (and similar issues have been reported many times), but in Version 13.1 we can finally close this bug!
Consider the differential equation (the Clairaut equation):
✕

What DSolve does by default is to give the generic solution to this equation, in terms of the parameter 𝕔_{1}. But the subtle point (which in optics is associated with caustics) is that the family of solutions for different values of 𝕔_{1} has an envelope which isnât itself part of the family of solutions, but is also a solution:
✕

In Version 13.1 you can request that solution with the option IncludeSingularSolutionsâTrue:
✕

And hereâs a plot of it:
✕

DSolve was a new function (back in 1991) in Version 2.0. Another new function in Version 2.0 was Residue. And in Version 13.1 weâre also adding an extension to Residue: the function ResidueSum. And while Residue finds the residue of a complex function at a specific point, ResidueSum finds a sum of residues.
This computes the sum of all residues for a function, across the whole complex plane:
✕

This computes the sum of residues within a particular region, in this case the unit disk:
✕

An important part of the builtin documentation for the Wolfram Language are what we call âguide pagesââpages like the following that organize functions (and other constructs) to give an overall âcognitive mapâ and summary of some area:
✕

In Version 13.1 itâs now easy to create your own custom guide pages. You can list builtin functions or other constructs, as well as things from the Wolfram Function Repository and other repositories.
Go to the âroot pageâ of the Documentation Center and press the icon:
✕

Youâll get a blank custom guide page:
✕

Fill in the guide page however you want, then use Deploy to deploy the page either locally, or to your cloud account. Either way, the page will now show up in the menu from the top of the root guide page (and theyâll also show up in search):
✕

You might end up creating just one custom guide page for your favorite functions. Or you might create several, say one for each task or topic you commonly deal with. Guide pages arenât about putting in the effort to create fullscale documentation; theyâre much more lightweight, and aimed more at providing quick (âwhat was that function called?â) reminders and âbigpictureâ mapsâleveraging all the specific function and other documentation that already exists.
At first it seemed like a minor feature. But once weâd implemented it, we realized it was much more useful than weâd expected. Just as you can style a graphics object with its color (and, as of Version 13.0, its filling pattern), now in Version 13.1 you can style it with its drop shadowing:
✕

Drop shadowing turns out to be a nice way to âbring graphics to lifeâ
✕

or to emphasize one element over others:
✕

It works well in geo graphics as well:

DropShadowing allows detailed control over the shadows: what direction theyâre in, how blurred they are and what color they are:
✕

Drop shadowing is more complicated âunder the hoodâ than one might imagine. And when possible it actually works using hardware GPU pixel shadersâthe same technology that weâve used since Version 12.3 to implement materialbased surface textures for 3D graphics. In Version 13.1 weâve explicitly exposed some wellknown underlying types of 3D shading. Hereâs a geodesic polyhedron (yes, thatâs another new function in Version 13.1), with its surface normals added (using the again new function EstimatedPointNormals):
✕

Hereâs the most basic form of shading: flat shading of each facet (and the specularity in this case doesnât âcatchâ any facets):
✕

Here now is Gouraud shading, with a somewhatfaceted glint:
✕

And then thereâs Phong shading, looking somewhat more natural for a sphere:
✕

Ever since Version 1.0, weâve had an interactive way to rotateâand zoom intoâ3D graphics. (Yes, the mechanism was a bit primitive 34 years ago, but it rapidly got to more or less its modern form.) But in Version 13.1 weâre adding something new: the ability to âdollyâ into a 3D graphic, imitating what would happen if you actually walked into a physical version of the graphic, as opposed to just zooming your camera:
✕

And, yes, things can get a bit surreal (or âtrekyâ)âhere dollying in and then zooming out:
There are some capabilities thatâover the course of yearsâhave been requested over and over again. In the past these have included infinite undo, high dpi displays, multiple axis plots, and others. And Iâm happy to say that most of these have now been taken care of. But thereâs oneâseemingly obscureââstragglerâ that Iâve heard about for well over 25 years, and that Iâve actually also wanted myself quite a few times: 3D Voronoi diagrams. Well, in Version 13.1, theyâre here.
Set up 25 random points in 3D:
✕

✕

Now make a Voronoi mesh for these points:
✕

To âsee insideâ we can use opacity:
✕

Why was this so hard? In a Voronoi thereâs a cell that surrounds each original point, and includes everywhere thatâs closer to that point than to any other. Weâve had 2D Voronoi meshes for a long time:
✕

But thereâs something easier about the 2D case. The issue is not so much the algorithm for generating the cells as it is how the cells can be represented in such a way that theyâre useful for subsequent computations. In the 2D case each cell is just a polygon.
But in the 3D case the cells are polyhedra, and to make a Voronoi mesh we have to have a polyhedral mesh where all the polyhedra fit together. And itâs taken us many years to build the large tower of computational geometry necessary to support this. Thereâs a somewhat simpler case based purely on cells that are always either simplices or hexahedraâthat weâve used for finiteelement solutions to PDEs for a while. But in a true 3D Voronoi thatâs not enough: the cells can be any (convex) polyhedral shape.
Here are the âpuzzle pieceâ cells for the 3D Voronoi mesh we made above:
✕

Pick 500 random points inside an annulus:
✕

✕

Version 13.1 now has a general function reconstructing geometry from a cloud of points:
✕

(Of course, given only a finite number of points, the reconstruction canât be expected to be perfect.)
The function also works in 3D:
✕

✕

ReconstructionMesh is a general superfunction that uses a variety of methods, including extended versions of the functions ConcaveHullMesh and GradientFittedMesh that were introduced in Version 13.0. And in addition to reconstructing âsolid objectsâ, it can also reconstruct lowerdimensional things like curves and surfaces:
✕

A related function new in Version 13.1 is EstimatedPointNormals, which reconstructs not the geometry itself, but normal vectors to each element in the geometry:
✕

In every new version for the past 30 years weâve steadily expanded our visualization capabilities, and Version 13.1 is no exception. One function weâve added is TernaryListPlotâan analog of ListPlot that conveniently plots triples of values where what oneâs trying to emphasize is their ratios. For example letâs plot data from our knowledgebase on the sources of electricity for different countries:
✕

The plot shows the âenergy mixtureâ for different countries, with the ones on the bottom axis being those with zero nuclear. Inserting colors for each axis, along with grid lines, helps explain how to read the plot:
✕

Most of the time plots are plotting numbers, or at least quantities. In Version 13.0, we extended functions like ListPlot to also accept dates. In Version 13.1 weâre going much further, and introducing the possibility of plotting what amount to purely symbolic values.
Letâs say our data consists of letters A through C:
✕

How do we plot these? In Version 13.1 we just specify an ordinal scale:
✕

OrdinalScale lets you specify that certain symbolic values are to be treated as if they are in a specified order. Thereâs also the concept of a nominal scaleârepresented by NominalScaleâin which different symbolic values correspond to different âcategoriesâ, but in no particular order.
Molecule lets one symbolically represent a molecule. Quantity lets one symbolically represent a quantity with units. In Version 13.1 we now have the new construct ChemicalInstance thatâs in effect a merger of these, allowing one to represent a certain quantity of a certain chemical.
This gives a symbolic representation of 1 liter of acetone (by default at standard temperature and pressure):
✕

We can ask what the mass of this instance of this chemical is:
✕

ChemicalConvert lets us do a conversion returning particular units:
✕

Hereâs instead a conversion to moles:
✕

This directly gives the amount of substance that 1 liter of acetone corresponds to:
✕

This generates a sequence of straightchain hydrocarbons:
✕

Hereâs the amount of substance corresponding to 1 g of each of these chemicals:
✕

ChemicalInstance lets you specify not just the amount of a substance, but also its state, in particular temperature and pressure. Here weâre converting 1 kg of water at 4Â° C to be represented in terms of volume:
✕

At the core of the Wolfram Language is the abstract idea of applying transformations to symbolic expressions. And at some level one can view chemistry and chemical reactions as a physical instantiation of this idea, where oneâs not dealing with abstract symbolic constructs, but instead with actual molecules and atoms.
In Version 13.1 weâre introducing PatternReaction as a symbolic representation for classes of chemical reactionsâin effect providing an analog for chemistry of Rule for general symbolic expressions.
Hereâs an example of a âpattern reactionâ:
✕

The first argument specifies a pair of âreactantâ molecule patterns to be transformed into âproductâ molecule patterns. The second argument specifies which atoms in which reactant molecules map to which atoms in which product molecules. If you mouse over the resulting pattern reaction, youâll see corresponding atoms âlight upâ:
✕

Given a pattern reaction, we can use ApplyReaction to apply the reaction to concrete molecules:
✕

Here are plots of the resulting product molecules:
✕

The molecule patterns in the pattern reaction are matched against subparts of the concrete molecules, then the transformation is done, leaving the other parts of the molecules unchanged. In a sense itâs the direct analog of something like
✕

where the b in the symbolic expression is replaced, and the result is âknitted backâ to fill in where the b used to be.
You can do what amounts to various kinds of âchemical functional programmingâ with ApplyReaction and PatternReaction. Hereâs an example where weâre essentially building up a polymer by successive nesting of a reaction:
✕

✕

Itâs often convenient to build pattern reactions symbolically using Wolfram Language âchemical primitivesâ. But PatternReaction also lets you specify reactions as SMARTS strings:
✕

Itâs been a 25year journey, steadily increasing our builtin PDE capabilities. And in Version 13.1 weâve added several (admittedly somewhat technical) features that have been much requested, and are important for solving particular kinds of realworld PDE problems. The first feature is being able to set up a PDE as axisymmetric. Normally a 2D diffusion term would be assumed Cartesian:
✕

But now you can say youâre dealing with an axisymmetric system, with your coordinates being interpreted as radius and height, and everything assumed to be symmetrical in the azimuthal direction:
✕

Whatâs important about this is not just that it makes it easy to set up certain kinds of equations, but also that in solving equations axial symmetry can be assumed, allowing much more efficient methods to be used:
✕

Also in Version 13.1 is an extension to the solid mechanics modeling framework introduced in Version 13.0. Just as thereâs viscosity that damps out motion in fluids, so thereâs a similar phenomenon that damps out motion in solids. Itâs more of an engineering story, and itâs usually described in terms of two parameters: mass damping and stiffness damping. And now in Version 13.1 we support this kind of socalled Rayleigh damping in our modeling framework.
Another phenomenon included in Version 13.1 is hyperelasticity. If you bend something like metal beyond a certain point (but not so far that it breaks), itâll stay bent. But materials like rubber and foam (and some biological tissues) can âbounce backâ from basically any deformation.
Letâs imagine that we have a square of rubberlike material. We anchor it on the left, and then we pull it on the right with a certain force. What does it do?
This defines the properties of our material:
✕

We define variables for the problem, representing x and y displacements by u and v:
✕

Now we can set up our whole problem, and solve the PDEs for it for each value of the force:
✕

✕

Then one can plot the results, and see the rubber being nonlinearly stretched:
✕

Thereâs in the end considerable depth in our handling of PDEbased modeling, and our increasing ability to do âmultiphysicsâ computations that span multiple types of physics (mechanical, thermal, electromagnetic, acoustic, …). And by now weâve got nearly 1000 pages of documentation purely about PDEbased modeling. And for example in Version 13.1 weâve added a monograph specifically about hyperelasticity, as well as expanded our collection of documented PDE models:
Letâs say you have trained a machine learning model and you apply it to a particular input. It gives you some result. But why? What were the important features in the input that led it to that result? In Version 13.1 weâre introducing several functions that try to answer such questions.
Hereâs some simple âtraining dataâ:
✕

We can use machine learning to make a predictor for this data:
✕

Applying the predictor to a particular input gives us a prediction:
✕

What was important in making this prediction? The "SHAPValues" property introduced in Version 12.3 tells us what contribution each feature made to the result; in this case v was more important than u in determining the value of the prediction:
✕

But what about in general, for all inputs? The new function FeatureImpactPlot gives a visual representation of the contribution or âimpactâ of each feature in each input on the output of the predictor:
✕

What does this plot mean? Itâs basically showing how often there are what contributions from values of the two input features. And with this particular predictor we see that thereâs a wide range of contributions from both features.
If we use a different method to create the predictor, the results can be quite different. Here weâre using linear regression, and it turns out that with this method v never has much impact on predictions:
✕

If we make a predictor using a decision tree, the feature impact plot shows the splitting of impact corresponding to different branches of the tree:
✕

FeatureImpactPlot gives a kind of birdâseye view of the impact of different features. FeatureValueImpactPlot gives more detail, showing as a function of the actual values of input features the impact points with those values would have on the final prediction (and, yes, the actual points plotted here are based on data simulated on the basis of the distribution inferred by the predictor; the actual data is usually too big to want to carry around, at least by default):
✕

CumulativeFeatureImpactPlot gives a visual representation of how âsuccessiveâ features affect the final value for each (simulated) data point:
✕

For predictors, feature impact plots show impact on predicted values. For classifiers, they show impact on (log) probabilities for particular outcomes.
One area that leverages many algorithmic capabilities of the Wolfram Language is control systems. We first started developing control systems functionality more than 25 years ago, and by Version 8.0 ten years ago we started to have builtin functions like StateSpaceModel and BodePlot specifically for working with control systems.
Over the past decade weâve progressively been adding more builtin control systems capabilities, and in Version 13.1 weâre now introducing model predictive controllers (MPCs). Many simple control systems (like PID controllers) take an ad hoc approach in which they effectively just âwatch what a system doesâ without trying to have a specific model for whatâs going on inside the system. Model predictive control is about having a specific model for a system, and then deriving an optimal controller based on that model.
For example, we could have a statespace model for a system:
✕

Then in Version 13.1 we can derive (using our parametric optimization capabilities) an optimal controller that minimizes a certain set of costs while satisfying particular constraints:
✕

The SystemsModelControllerData that we get here contains a variety of elements that allow us to automate the control design and analysis workflow. As an example, we can get a model that represents the controller running in a closed loop with the system it is controlling:
✕

Now letâs imagine that we drive this whole system with the input:
✕

Now we can compute the output response for the system, and we see that both output variables are driven to zero through the operation of the controller:
✕

Within the SystemsModelControllerData object generated by ModelPredictiveController is the actual controller computed in this caseâusing the new construct DiscreteInputOutputModel:
✕

What actually is this controller? Ultimately itâs a collection of piecewise functions that depends on the values of states x_{1}[t] and x_{2}[t]:
✕

And this shows the different statespace regions in which the controller has:
✕

In Version 13.0 we introduced our question and assessment framework that allows you to author things like quizzes in notebooks, together with assessment functions, then deploy these for use. In Version 13.1 weâre adding capabilities to let you algorithmically or randomly generate questions.
The two new functions QuestionGenerator and QuestionSelector let you specify questions to be generated according to a template, or randomly selected from a pool. You can either use these functions directly in pure Wolfram Language code, or you can use them through the Question Notebook authoring GUI.
When you select Insert Question in the GUI, you now get a choice between Fixed Question, Randomized Question and Generated Question:
✕

Pick Randomized Question and youâll get
✕

which then allows you to enter questions, and eventually produce a QuestionSelectorâwhich will select newly randomized questions for every copy of the quiz thatâs produced:
✕

Version 13.1 also introduces some enhancements for authoring questions. An example is a pureGUI ânocodeâ way to specify multiplechoice questions:
✕

In the Wolfram Language expressions normally have two aspects: they have a structure, and they have a meaning. Thus, for example, Plus[1,1] has both a definite tree structure
✕

and has a value:
✕

In the normal operation of the Wolfram Language, the evaluator is automatically applied to all expressions, and essentially the only way to avoid evaluation by the evaluator is to insert âwrappersâ like Hold and Inactive that necessarily change the structure of expressions.
In Version 13.1, however, thereâs a new way to handle âunevaluatedâ expressions: the "ExprStruct" data structure. ExprStructs represent expressions as raw data structures that are never directly seen by the evaluator, but can nevertheless be structurally manipulated.
This creates an ExprStruct corresponding to the expression {1,2,3,4}:
✕

This structurally wraps Total around the list, but does no evaluation:
✕

One can also see this by âvisualizingâ the data structure:
✕

Normal takes an ExprStruct object and converts it to a normal expression, to which the evaluator is automatically applied:
✕

One can do a variety of essentially structural operations directly on an ExprStruct. This applies Plus, then maps Factorial over the resulting ExprStruct:
✕

The result is an ExprStruct representing an unevaluated expression:
✕

With "MapImmediateEvaluate" there is an evaluation done each time the mapping operation generates an expression:
✕

One powerful use of ExprStruct is in doing code transformations. And in a typical case one might want to import expressions from, say, a .wl file, then manipulate them in ExprStruct form. In Version 13.1 Import now supports an ExprStructs import element:
✕

This selects expressions that correspond to definitions, in the sense that they have SetDelayed as their head:
✕

Hereâs a visualization of the first one:
✕

Letâs say youâve got external code thatâs in a compiled Ccompatible dynamic library. An important new capability in Version 13.1 is a superefficient and very streamlined way to call any function in a dynamic library directly from within the Wolfram Language.
Itâs one of the accelerating stream of developments that are being made possible by the largescale infrastructure buildout that weâve been doing in connection with the new Wolfram Language compilerâand in particular it often leverages our sophisticated new typehandling capabilities.
As a first example, letâs consider the RAND_bytes (“cryptographically secure pseudorandom number generator”) function in OpenSSL. The C declaration for this function is:
In Version 13.1 we now have a symbolic way to represent such a declaration directly in the Wolfram Language:
✕

(In general weâd also have to specify the library that this function is coming from. OpenSSL happens to be a library thatâs loaded by default with the Wolfram Language so you donât need to mention it.)
There are quite a few new things going on in the declaration. First, as part of our collection of compiled types, weâre adding ones like "CInt" and "CChar" that refer to raw C language types (here int and char). Thereâs also CArray which is for declaring C arrays. Notice the new ::[ ... ] syntax for TypeSpecifier that allows compact specifications for parametrized types, like the char* here, that is described in Wolfram Language as "CArray"::["CChar"].
Having set up the declaration, we now need to create an actual function that can take an argument from Wolfram Language, convert it to something suitable for the library function, then call the library function, and convert the result back to Wolfram Language form. Hereâs a way to do that in this case:
✕

What we get back is a compiled code function that we can directly use, and that works by very efficiently calling the library function:
✕

The FunctionCompile above uses several constructs that are new in Version 13.1. What it fundamentally does is to take a Wolfram Language integer (which it assumes to be a machine integer), cast it into a C integer, then pass this to the library function, along with a specification of a C char * into which the library function will put its result, and from which the final Wolfram Language result will be retrieved.
Itâs worth emphasizing that most of the complexity here has to do with handling data types and conversions between themâsomething that the Wolfram Language goes to a lot of trouble to avoid usually exposing the user to. But when weâre connecting to external languages that make fundamental use of types, thereâs no choice but to deal with them, and the complexity they involve.
In the FunctionCompile above the first new construct we encounter is
✕

The basic purpose of this is to create the buffer into which the external function will write its results. The buffer is an array of bytes, declared in C as char *, or here as "CArray"::["CChar"]. Thereâs an actual wrinkle though: whoâs going to manage the memory associated with this array? The "Managed":: type specifier says that the Wolfram Language wrapper will do memory management for this object.
The next new construct we see in the FunctionCompile is
✕

Cast is one of a family of new functions that can appear in compilable code, but have no significance outside the compiler. Cast is used to specify that data should be converted to a form consistent with a specified type (here a C int type).
The core of the FunctionCompile is the use of LibraryFunction, which is what actually calls the external library function that we declared with the library function declaration.
The last step in the function compiled by FunctionCompile is to extract data from the C array and return it as a Wolfram Language list. To do this requires the new function FromRawPointer, which actually retrieves data from a specified location in memory. (And, yes, this is a raw dereferencing operation that will cause a crash if it isnât done correctly.)
All of this may at first seem rather complicated, but for what itâs doing, itâs remarkably simpleâand greatly leverages the whole symbolic structure of the Wolfram Language. Itâs also worth realizing that in this particular example, weâre just dipping into compiled code and then returning results. In largerscale cases weâd be doing many more operationsâtypically specified directly by toplevel Wolfram Language codeâwithin compiled code, and so type declaration and conversion operations would be a smaller fraction of the code we have to write.
One feature of the example weâve just looked at is that it only uses builtin types. But in Version 13.1 itâs now possible to define custom types, such as the analog of C structs. As an example, consider the function ldiv from the C standard library. This function returns an object of type ldiv_t, defined by the following typedef:
Hereâs the Wolfram Language version of this declaration, based on setting up a "Product" type named "CLDivT":
✕

(The "ReferenceSemantics"False option specifies that this type will actually be passed around as a value, rather than just a pointer to a value.)
Now the declaration for the ldiv function can use this new custom type:
✕

The final definition of the call to the external ldiv function is then:
✕

And now we can use the function (and, yes, it will be as efficient as if weâd directly written everything in C):
✕

The examples weâve given here are very small ones. But the whole structure for external function calls thatâs now in Version 13.1 is set up to handle large and complex situationsâand indeed weâve been using it internally with great success to set up important new builtin pieces of the Wolfram Language.
One of the elements thatâs often needed in more complex situations is more sophisticated memory management, and our new "Managed" type provides a convenient and streamlined way to do this.
This makes a compiled function that creates an array of 10,000 machine integers:
✕

Running the function effectively âleaksâ memory:
✕

But now define a version of the function in which the array is âmanagedâ:
✕

Now the memory associated with the array is automatically freed when it is no longer referenced:
✕

If you have an explicit pure function (Function[...]) you can use FunctionCompile to produce a compiled version of it. But what if you have a function thatâs defined using downvalues, as in:
✕

In Version 13.1 you can directly compile function definitions like this. Butâas is the nature of compilationâyou have declare what types are involved. Here is a declaration for the function fac that says it takes a single machine integer, and returns a machine integer:
✕

Now we can create a compiled function that computes fac[n]:
✕

The compiled function runs significantly faster than the ordinary symbolic definition:
✕

✕

The ability to declare and use downvalue definitions in compilation has the important feature that it allows you to write a definition just once, and then use it both directly, and in compiled code.
An early focus of the Wolfram Language compiler is handling lowlevel âmachineâ types, such as integers or reals of certain lengths. But one of the advances in the Version 13.1 compiler is direct support for an "InertExpression" type for representing any Wolfram Language expression within compiled code.
When you use something like FunctionCompile, it will explicitly try to compile whatever Wolfram Language expressions itâs given. But if you wrap the expressions with InertExpression the compiler will then just treat the expressions as inert structural objects of type "InertExpression". This sets up a compiled function that constructs an expression (implicitly of type "InertExpression"):
✕

Evaluating the function constructs and then returns the expression:
✕

Normally, within the compiler, an "InertExpression" object will be treated in a purely structural way, without any evaluation (and, yes, itâs closely related to the "ExprStruct" data structure). But sometimes itâs useful to perform evaluation on it, and you can do this with InertEvaluate:
✕

Now the InertEvaluate does the evaluation before wrapping Hold around the inert expression:
✕

The ability to handle expressions directly in the compiler might seem like some kind of detail. But itâs actually hugely important in opening up possibilities for future development with the Wolfram Language. For the past 35 years, weâve internally been able to write lowlevel expression manipulation code as part of the C language core of the Wolfram Language kernel. But the ability of the Wolfram Language compiler to handle expressions now opens this upâand lets anyone write maximally efficient code for manipulating expressions that interoperate with everything else in the Wolfram Language.
Even beyond all the things Iâve discussed so far, there are all sorts of further additions and enhancements in Version 13.1, dotted throughout the system.
InfiniteLineThrough and CircularArcThrough have been added for geometric computation, and geometric scene specification. Geometric scenes can now be styled for custom presentation:
✕

There are new graph functions: GraphProduct, GraphSum and GraphJoin:
✕

And there are new builtin families of graphs: TorusGraph and BuckyballGraph:
✕

You can mix images directly into Graphics (and Graphics3D):
✕

AbsoluteOptions now resolves many more options in Graphics, telling you what explicit value was used when you gave an option just as Automatic.
The function LeafCount now has a Heads option, to count expression branches inside heads. Splice works with any head, not just List. Functions like IntersectingQ now have SameTest options. You can specify TimeZone options using geographic entities (like cities).
FindClusters now lets you specify exactly how many clusters you want to partition your data into, as well as supporting UpTo[n].
In neural nets, ElementwiseLayer now supports âmodernâ nonconvex nonmonotonic activation functions like Mish and GELU, AttentionLayer supports dropout and local masking, ReplicateLayer now supports integer arrays, and RandomArrayLayer supports further statistical distributions. NetTrain now handles multioutput and nonscalar losses. Image encoders and decoders support resampling and padding, and thereâs now support for nuclear sampling. Our support for the ONNX transfer format continues to grow, with net operators added in Version 13.1.
CenteredIntervalâintroduced in Version 13.0ânow supports 36 further special functions (and, yes, each one needs theorems proved to make this work).
Thereâll be more coming on this in subsequent versions, but in Version 13.1 weâre beginning the introduction of structured matrices that are stored and computed with in special, optimized ways. Examples include PermutationMatrix and LowerTriangularMatrix.
Weâve had extensive support for computational microscopy for a while. But in Version 13.1 the "BioImageFormat" Import format now adds importing of the more than 160 raw image formats used by different kinds of microscopes.
Version 13.0 dramatically expanded our ability to import PDF. Weâve further enhanced this in Version 13.1, for example allowing positioned text to be imported into graphics as Text primitives.
Weâve supported standard text styles like bold and italic forever, but now we have a standard way to handle struckthrough text as well:
✕

In addition to all these âinsidethesystemâ enhancements, weâve also finished making it possible to download desktop versions of Wolfram Language on all platforms (including Linux) while leaving documentation on the web. Documentation installation can also now be configured globally on a permachine basis, rather than just on a peruser basis.
Soâas of today, documentation or notâyou can get Version 13.1 on your computer. Oh, and the Wolfram Cloud has also now been updated to use Version 13.1. I hope you enjoy the new features, and this next step on the epic journey of Mathematica and the Wolfram Language.
]]>
âWeâre going to launch lots of tiny spacecraft into interstellar space, have them discover alien intelligence, then bring back its technology to advance human technology by a million yearsâ. Iâve heard some pretty wacky startup pitches over the years, but this might possibly be the alltime winner.
But as I thought about it, I realized that beyond the âabsurdly extreme moonshotâ character of this pitch, thereâs some science that Iâve done that makes it clear that itâs also fundamentally philosophically confused. The nature of the confusion is interesting, however, and untangling it will give us an opportunity to illuminate some deep features of both intelligence and technologyâand in the end suggest a way to think about the longterm trajectory of the very concept of technology and its relation to our universe.
Letâs start with a scenario. Letâs say one of the little spacecraft comes across a planet where it sees complicated swirling patterns:
✕

The spacecraft sends out a probe to âmake contactâ. The swirling pattern ârespondsâ by changing slightly. The spacecraft analyzes the change, and sends out another probe. And pretty soon thereâs a whole âconversationâ going on between the spacecraft and the planet. But, you might say, thatâs nothing like an âintelligenceâ there; thereâs just a âpure physical systemâ that operates through physical laws.
OK, but now letâs imagine the spacecraft has returned to Earth and is checking it out. It detects complicated patterns of radio signals. It sends out a radio signal of its own. Something on Earth responds. A âconversationâ ensues. Maybe the spacecraft is âtalking toâ a cellphone tower, doing automated handshakes with it. Maybe it reached a ham radio operator, and is exchanging Morse code with them. Or maybeâin an ultimate version of code injectionâthereâs a computer thatâs interpreting the spacecraftâs signals as a program, and is sending back the results of running the program.
It all seems quite sophisticatedâand at some level worthy of the technological civilization weâve built up here on Earth. But letâs zoom out a bit. Thereâs something coming from the spacecraft, thatâs causing something to happen on Earth, thatâs causing something to be returned to the spacecraft.
And ultimately whatever is happening on Earth must be a physical process of some kindâoperating according to the laws of physics. So whatâs the difference between this and those swirling âjust physicsâ patterns that the spacecraft found on the other planet? Everything is ultimately âjust physicsâ after all.
OK, you might say, thatâs surely true. But on Earth, even though we might have started from physics, weâve somehow now âascendedâ through chemistry and biology and technology to get to something thatâs fundamentally more sophisticated. But here we run into an importantâif at first surprisingâpiece of basic science: my Principle of Computational Equivalence.
Letâs say we represent all those âphysical processesâ as computations (and our Physics Project implies that all of physics is indeed ultimately computational). Now we can compare the computations that correspond to the planet with the swirling patterns to the ones that correspond to our Earth with us humans in the loop.
And what the Principle of Computational Equivalence tells us is that theyâre ultimately equivalent. The computations associated with the swirling patterns are ultimately just as sophisticated as the ones we achieve with our brains and our technology here on Earth. Itâs far from obvious that this would be true. But itâs something one discovers when one explores the computational universe of possible programs.
One might think that simple programs would produce only simple behavior, and that somehow the behavior would get progressively more complex with more complicated programs. But thatâs not what one finds. Instead, thereâs increasing evidence that almost any program that doesnât show obviously simple behavior can in fact show behavior that is as sophisticated as anything.
Itâs been known for about a century that there exist computation universal systems capable of being âprogrammedâ to do essentially any computation. But what the Principle of Computational Equivalence says is that sophisticated computation is not only possibleâeven for simple programsâbut is something that happens generically and ubiquitously.
So what does this mean for our spacecraft? It means that what the spacecraft sees on Earth can be computationally no more sophisticated than what it sees on the planet with the swirling patterns. Yes, we consider there to be âintelligenceâ here on Earth. But what the Principle of Computational Equivalence tells us is that ultimately thereâs nothing abstractly different going on from whatâs going on in the swirling patterns.
So if we characterize whatâs going on here on Earth as an example of âintelligenceâ we really should say that those swirling patterns are also âexamples of intelligenceâ. And, yes, it doesnât seem much like human intelligence. But at an abstract computational level itâs really operating like intelligenceâbut to us humans itâs âalien intelligenceâ.
Thereâs a common saying: âThe weather has a mind of its ownâ. And what the Principle of Computational Equivalence tells us is that, yes, fluid dynamics in the atmosphereâand all the swirling patterns associated with itâare examples of computation that are just as sophisticated as those associated with human minds.
But, OK, so thereâs a sense in which the weather âhas a mind of its ownâ. But itâs definitely not a âhumanlike mindâ. Yes, the weather does sophisticated computations. But thereâs no obvious way to attribute to those computations the purposes and intentions and other typical features of how we describe what goes on in a human mind. So if indeed weâre going to talk about the weather as being an intelligence, for us humans we have to consider it an âalien intelligenceâ.
We started off talking about spacecraft going out into the cosmos to discover alien intelligence. But what the Principle Computational Equivalence is telling us is that actually thereâs what we can think of as alien intelligence all around us. Yes, we humans have managed to get to the point where we do all sorts of sophisticated computations. But computations of just the same sophistication are being done in all sorts of systems that donât have that whole human tower of biology and technology.
For a long time itâs been a mystery why weâve never detected alien intelligence out there in the cosmos. But actually I think thereâs no lack of âalien intelligenceâ; indeed itâs all around us. But the point is that it really is alien. At an abstract computational level itâs like our intelligence. But in its details it’s not aligned with our intelligence. Abstractly itâs intelligence, but itâs not humanlike intelligence. Itâs alien intelligence.
OK, so we can think of lots of systems as being examples of âalien intelligenceâ. But how does that alien intelligence connect to our human intelligence? Sometimes itâs close enough that we humans can immediately âanthropomorphizeâ the system to âunderstand what itâs doing in human termsâ. But often we need to put effort into âmaking a bridgeâ. And in fact we can view that as being what science and technology are ultimately trying to do.
Let’s say we’re looking at swirling patterns in a fluid. The fluid is doing what it does, in effect continually running a computation that generates its behavior. But how can we “align” that with what’s going on in our brains? That’s where science comes in. Because what science is trying to do is to extract some kind of “humanrelatable narrative” from the actual behavior of a system out there in the world. Or in some sense itâs trying to provide a âchannelâ through which we can “communicate” with the “alien intelligence” that is embodied in whatâs out there in the world.
So what about technology? Fundamentally technology is about trying to take what exists out there in the world, and apply it to achieve human purposes. We have a fluid. Now we use it to create hydraulic technology that achieves some practical human purpose. We can see the history of technology as being a progressive effort to identify things out there in the world (metal ore, photoelectricity, liquid crystals, …) that can be sampled and fashioned in such a way as to achieve certain purposes we want.
And insofar as we think of whatâs out there in the world as being like alien intelligence, what technology is doing is finding ways to corral that intelligence into achieving human purposes. The truth is that in most of our technology today, weâre not letting that intelligence really do anything close to what it’s capable of. Weâre keeping it tightly constrained to take only steps that we can readily understand and foresee. Itâs a bit like having a horse with a harness that constrains it to just walk slowly in a straight lineâeven though without the harness the horse could gallop around and do all sorts of elaborate things, albeit things that we might not readily be able to understand or foresee.
So letâs come back to the spacecraft. Itâs reached a planet. And itâs interacting with whatâs there. Perhaps thereâs some weird electrical storm going on. And, yes, we can think of that as an example of alien intelligence. But if the mission of the spacecraft is to discover technology then what it needs to do is to figure out whether thereâs some way to interact with the electrical storm so as to achieve some human purpose.
The storm does what the storm does. But maybe by moving some piece of metal around in just the right way itâs possible to get the storm to charge a battery. Or, more elaborately, perhaps processes in the storm could be used like an analog computer, say to compute solutions to equations. And perhapsâhaving seen the storm on this planetâitâs even possible to âbottle it upâ and replicate it, say in a piece of consumer electronics.
One way to describe whatâs going on is just to say rather prosaically that we discovered a phenomenon on the planet, that we were able to use for technology. But more colorfully we could say that we encountered an alien intelligence, we found a way to communicate with it, and then we âbrought backâ technology from it.
The original startup pitch was about spacecraft getting technology by discovering alien intelligence out in the cosmos. But really the whole spacecraft thing is a distraction. Because actuallyâas weâve discussedâthereâs plenty we can describe as âalien intelligenceâ all around us, even right here on Earth. And the issue is in a sense just how to âcommunicate with itâ and find ways to âharness itâ for our technological purposes.
Weâve learned in the past century that we can use electrons in semiconductors as a way to build computers. But what about other physical processes? Maybe flowing fluids, for example. Can we use that âalien intelligenceâ to make a new kind of computer? In the end, the point is that any technology is about finding and harnessing âalien intelligenceâ. Thatâs basically just what technology is, and always has been.
The whole âalien intelligenceâ part of the story, though, is much more relevant when weâre thinking of technology that makes serious use of what we can identify as sophisticated computation. If weâre just using a system from nature for its physical mass, it doesnât really feel as if weâre using its âintelligenceâ. But as soon as we try, for example, to base a general computer on it, itâs a quite different story.
In getting technology from the universe weâre basically picking out certain aspects of what exists and choosing to apply these for our purposes. In doing science it seems like we have âless choiceâ about what aspects of the universe we deal with. After all, we might imagine that science is trying to give us a way to understand anything thatâs out there in the universe. But in reality itâs much more like technology. The âscientific narrativesâ that we understandâat least at a given time in historyâare ones that weâre in a sense âprimed forâ. Yes, something like fluid turbulence might give us âinyourfaceâ exposure to something computationally sophisticated thatâs far from what we normally talk about. But what science mostly concentrates on is creating narratives that are aligned with our existing scientific understanding and discussionsâmuch as technology is set up to be about things that are aligned with our existing human purposes.
One might imagine thatâwherever it ultimately comes fromâtechnology must at least always in the end be based on the laws of physics. But whatâs emerging from our Physics Project is that actually the story is considerably more complicated than that.
It all begins with the ruliad: the object that represents the entangled limit of all possible computations. The ruliad is a unique, formally necessary object, that in a sense embodies all conceivable existence. And inevitably we are embedded within the ruliad, sampling certain aspects of it to form our perception of reality.
In principle there are all sorts of kinds of observers of the ruliad, with all sorts of kinds of perceptions of reality. But the key point that has emerged as a foundation of our Physics Project is that âobservers like usâ have certain general characteristicsâspecifically that we assume that we are persistent through time, and also that we are computationally boundedâand from these characteristics alone, we can abstractly deduce from the structure of the ruliad that we must âexperienceâ core standard laws of known physics.
The ruliad in a sense contains all possible physicses. But itâs our particular kind of sampling of the ruliad that leads us to the particular laws of physics that we currently know. An âalien intelligenceâ might sample the ruliad quite differently, and thus in effect âexperienceâ quite different laws of physics.
Somewhere underneath everything we can think of there being a giant hypergraph of individual atoms of existenceâbut with the means of perception observers like us have, we inevitably âcoarse grainâ to the point where, for example, we experience this as continuous space. Another kind of observer, with different characteristics, might, for example, not do that coarse graining, might never experience continuous space, and might have a completely different perception of how the universe works.
In some sense, therefore, physics is much more like technology than we might expect. There isnât an âabsolute physicsâ. Thereâs just the physics that we as observers extract from the ruliad. Much like thereâs particular technology that we choose to build from the âraw materialâ that exists. Put another way, both physics and technology are ultimately things we âextractâ from the ruliad, in effect by making certain choices.
How we âextractâ physics seems, however, much more constrained. For example, we as humans have only certain particular senses through which we are biologically set up to experience the world. Yet we have the feeling that in technology we can in effect âconstruct whatever we wantââalthough inevitably âwhat we wantâ is also still at least influenced by how we are biologically set up.
Weâre very used to the idea that over time technology progressesâas we invent more, and work out new ways to use our âraw materialâ to achieve human purposes. But physics as a science progresses too. And in a sense whatâs happening there is that weâre expanding our character as observers to be able to perceive and experience more of âwhatâs going onââultimately in the ruliad.
Part of that expansion is actually a matter of technology. Weâre building telescopes and microscopes and amplifiers that allow us to extend our raw human senses to be sensitive to more things. But thereâs also another part of the expansion that is in effect intellectual: weâre developing new conceptual frameworks that allow us to âcorralâ things we see happening in the world into forms that âfit narrativesâ weâve constructed.
And the important point here is that neither our technology nor our physics is fixed. Theyâre in a sense coevolvingâgradually allowing more and more of the ruliad to be pulled into our narratives and our purposes. Or, put another way, what we observe is gradually expanding to encompass more and more of the ruliad, and to be able to make use of more and more of it.
How are âdifferent intelligencesâ manifest in the ruliad? We can imagine organizing the ruliad to be laid out in some form of rulial space. And from each point in rulial space one in effect gets a âdifferent perspectiveâ on the ruliad. And that’s at least the beginning of the story of how “different intelligences” exist and experience the ruliad.
Itâs similar to what happens with physical space: from different places in physical space one gets a different perspective on the universe. In physical space we have a concept of motion: that observers like us can move from one place in space to another while in effect maintaining our coherence and integrity.
How does this work in rulial space? We can think of different points in rulial space as corresponding to different computations, with different rules. So rulial motion in effect corresponds to making a translation between one computation and another. At the outset, itâs not obvious this would even in principle be possible. But the Principle of Computational Equivalence implies that it ultimately will be. The computations at different points in rulial space will (almost always) be equivalent in their sophisticationâand as is typical with universal computationâitâll therefore in principle be possible to have an âinterpretation processâ that translates between them.
But the big question is whether this can be achieved in practice. Just how far can a particular observer translate in rulial space while maintaining their coherence and integrity?
The ruliad is a complex and (if sampled across slices in time) continually changing thing. But a critical feature is that there can be structures that have a certain persistence within it. In physical space these are things like particles (as well as black holes) that behave like âstable lumps of spaceââor like stable lumps in certain projections of the ruliad. In rulial space there can presumably also be structures with a certain persistence: “particles” of rulial space. And these âparticlesâ somehow correspond to features that âsurvive across different computational perspectivesââor in effect represent ârobust conceptsâ.
When we talk about âdifferent intelligencesâ a very familiar example is different human minds. And in a sense we can think of different human minds as being laid out in rulial spaceâwith each mind being at a different rulial position, and thus having a different computational rule by which it operates, and a different âexperience of the ruliadâ.
So how can these minds âcommunicateâ? Ultimately it is through ârulial motionâ. But potentially the most robust form of rulial motion is through rulial particlesâwhich weâve identified above with the abstract idea of ârobust conceptsâ. Put in a practical way: different (human) minds operate internally in different ways. But they can still âcommunicateâ by exchanging something that in effect âsurvives translationâ between one mind and another: rulial particles corresponding to robust concepts (say expressed in a language).
But, OK, we can imagine rulial space with lots of human minds laid out at different places, with ones that communicate more easily closer together. So what about âalien intelligencesâ? Well, each one is somewhere in rulial space. But they may be far away from where our human minds are.
We can imagine our rulial particlesâor ârobust conceptsââbeing able to reach a certain distance in rulial space. The human idea of âexcitementâ might for example be able to reach the place in rulial space where weâd find the minds of dogs. But what about the weather, for example? Well, as an alien intelligence, itâs presumably much further away in rulial spaceâand, anthropomorphize it as we mightâitâs not clear what its notion of âexcitementâ would be.
Itâs an oftenasked question whyâwith our spacecraft and radio telescopes and everything elseâwe havenât ever run across what we consider to be ânaturally occurringâ alien intelligences. In the past we might have imagined that the answer is that there just isnât anything like âintelligenceâ (outside of us humans) to be found in any part of the universe that we can probe. But the Principle of Computational Equivalence says thatâs fundamentally not true, and that in fact âabstract intelligenceâ is thoroughly ubiquitous among systems with all but the most obviously simple behavior.
So to âfindâ alien intelligence itâs not that we need a more powerful radio telescope (or a better spacecraft) that can reach further in physical space. Rather, the issue is to be able to reach far enough in rulial space. Or, put another way, even if we view the weather as âhaving a mind of its ownâ, the rulial distance between âits mindâ and our human minds may be too great for us to be able to âunderstandâ and âcommunicate with itâ.
So what will it take for us to âbridge this rulial gapâ? At some level itâs just about building the right science and technology. We can think of science as being about defining a way to âtranslateâ from the computational rules by which some particular system operates to the computational way our human minds operate. Or, in terms of rulial space, finding a way to âmoveâ from the rulial position of the system to the rulial position of our mindsâand translating from the way a system works to a âhuman narrativeâ that represents it.
Centuries ago we might have just said âthe planets do what they doâ; maybe their motion in space is driven by an âalien intelligenceâ that we donât understand. But then along came mathematical science and we were able to âtranslateâ from the intrinsic computation done by the planets to a mathematical description that we internalized enough to consider it a human narrative that we understand.
In some sense at any given time in intellectual history our minds âreach out a certain distance in rulial spaceâ. Weâve developed conceptual frameworks that allow us to maintain a coherent understanding of a certain range of thingsâwith that range growing as we invent new frameworks. At one time our âdomain of understandingââor the region of rulial space that we could reachâdidnât encompass the behavior of electricity. But our âintellectual expansionâ in rulial space eventually reached this, and the result is that we can now use electricity as âraw materialâ from which to construct technology.
One way we âexpand our reach in rulial spaceâ is in effect conceptual: by expanding what we understand. But another way is by being able to âsenseâ or âmeasureâ more. When we invent radioâor, for that matter, gravitational wave detectionâthere are immediately new kinds of processes that we manage to âconnect to human experienceâ. Or, put another way, there are more distant parts of the ruliad that weâre able to reach.
More prosaically, we can say that if we want to be able to use something for technology, weâd better be able to detect that itâs there, and weâd better be able to understand it well enough that we can see how it could align with our human purposes. We can think of the ruliad as being full of alien intelligencesâwith plenty of capabilities to âmineâ. But to be able to actually mine something for our technological purposes we have to be able to reach it across rulial space; we have to be able to connect it to us.
So what does this mean for the original startup pitch? Yes, itâs a good idea to âmine alien intelligencesâ for technology. In fact, thatâs basically where technology always comes from. But thereâs no need to send out spacecraft, âdiscoverâ alien intelligence, and so on. There are âalien intelligencesâ all around us; the issue is just to reach them across rulial space, and be able to âcommunicateâ with them. But what weâve argued is that the process of progressively reaching out in rulial space is just the general process of progressively advancing science (and the technology on which it depends).
So, yes, by all means explore more of whatâs out there in the world, with more, different kinds of sensors and measurements. Then try to âunderstandâ what you see enough to be able to tell how to align it with human purposes, and make technology out of it. But thereâs no pressing need for interstellar spacecraft in this picture. Itâs just a matter of doing more science to expand our domain in the ruliad, and mine more of rulial space.
We can think of technology as being about setting up things that exist in the world (or ultimately in the ruliad) to achieve human purposes. And weâve talked about how the advance of science and technology allows us to progressively reach further in rulial space to get âraw materialâ for our technology. But weâve said that technology is intended to âachieve human purposesâ. So what might those purposes ultimately be?
Our purposes have certainly evolved over the course of human history. In todayâs world, we might view it as purposeful to walk on a treadmill, or to trade cryptocurrencies. But it would be challenging to explain the purpose of such things to someone from even a few hundred years ago.
In a sense, purposes evolve as we build new conceptual frameworks, and as we set up technology that allows us to do new things. More abstractly, we might say that purposes are also something defined by places in rulial space. So when we talk about the evolution of purposes, what weâre really asking is where in rulial space our history and development has led us, and will lead us in the future.
And certainly in the vastness of the whole ruliad, our existing human purposes occupy just an infinitesimally tiny part. Think, for example, of the natural world even as we are currently aware of it. The vast majority of things in it do not seem in any way aligned with our purposesâand we have not been able to mine them for technology. Historically, however, thereâs been progressive expansion in the domain of our purposes. There was a time when we knew about magnetic rocks, but had no purpose for magnetism. But over the course of time, from compasses to actuators to memories, more and more human purposes have emerged that connect to the phenomenon of magnetism.
And in a sense we can view the whole core trajectory of human progress as being about the expansion of the region of rulial spaceâand the ruliadâthat represents our purposes. So how will this evolve?
As Iâve discussed extensively before, there seem to be two central features that we as entities in the ruliad have. First, that we are computationally bounded. And second, that we believe we are persistent in time. Computational boundedness is essentially the statement that the region of rulial space that we occupy is limited. In some sense our minds can coherently span a certain region of rulial space, but itâs a bounded region.
What about persistence in time? It means that even though we are always being reconstructed out of different atoms of existence (and different atoms of space), we conflate things to the point where we experience a single continuous thread of existence.
Taken together, these features suggest a picture of us being a kind of âblobâ that gradually moves around in rulial space. Does it matter that there isnât just a single human mind? Well, yes. Without some kind of âobserverâ thereâs no real way to even define what it means to have a âblobâ. And in the end itâs a story of consistency of observers observing observers. But the result is that we can think of our whole collective âflotillaâ of human purposes as being something localized that moves around in rulial space, expanding the region of the ruliad that it reaches.
But just how far can this go? Imagine that at some time in the distant future we have successfully exploredâand âcolonizedââmuch of rulial space. To do this weâd certainly have to have broken out of the particular constraints of our biological construction, and made use of âadditional raw materialâ in the ruliad.
But what would it mean to be spread across a large swath of rulial space? Our very notion of existence seems to depend on localization in rulial space. The thing that we view as âusâ is something particular and coherent. To be âbiggerâ in rulial space is to deny that particularity and coherence, and to become something generic that does not represent any kind of âspecific entity that existsâ.
In a sense, itâs a pyrrhic view of the ultimate limit of our technological and other evolution. As we progress, we gradually âmineâ more and more of the ruliad, pulling it into the domain of technology and of our âhumanâ (or posthuman) purposes. But in doing so, we eventually transcend the very characteristics that we identify with existence. In other words, if we go too far with our expansion in the ruliad, we simply cease to exist, at least in the sense that we currently define existence.
Put another way, if we âabsorbâ more and more âalien intelligenceâ thereâs eventually no longer any coherent âusâ. Of course, the very notion of coherence is something weâre basically defining from our current human view of things. And no doubt there are other definitions that could be given. But theyâre certainly far away from our current place in rulial space, and itâs not even clear they can be reached without some kind of âdiscontinuity of motionâ that would in effect fundamentally break their connection to us as we are now.
At a fundamental level, the ruliad is a purely computational object, that we can think of as being made of pure, abstract atoms of existence (or âemesâ). When observers like us sample the ruliad we can attribute to it the characteristics that correspond to our perception of physical reality. And a notable feature of that sampling is that it supports the idea of pure motion in physical space. In other words, it allows for the possibility that structures can âmaintain their perceived physical integrityâ while being âreformedâ out of different atoms of space, which themselves are interpretations of the pure atoms of existence in the ruliad.
But as soon as we start thinking about any kind of serious motion in rulial (rather than physical) space it no longer makes sense to talk about anything like âmaintaining physical integrityâ, not least because in different places in rulial space the very notion of physics changes. But wherever we are in the ruliad we can still think about whatâs going on as computation. We might have some way of observing or sampling the ruliad that gives us some perception of realityâlike physics, or mathematics. But if we âatomizeâ things down to the lowest level, weâll always find raw computation.
As âphysical observers like usâ we only have limited capabilities to probe or manipulate the raw ruliad and affect what we perceive as physical reality. We can move physical objects around, maintaining what we observe of their structure. In principle we could imagine deconstructing objects into individual atoms of existence, then recreating them âtransporter styleâ somewhere else in physical space. But as of now, we donât know how to do this, and most likely itâs not possible for observers like usâbecause it would require âoutcomputingâ computationally irreducible features of the structure of space down at the level of individual atoms of space, which is far from what computationally bounded observers like us can expect to do.
But what about raw computation, of the kind that ultimately makes up the ruliad? There the story is different. Because weâre no longer constrained by our character as physical observers, so weâre free to in effect âmake up any computation we wantâ. To explore the physical universe we need physical motion or something like it. And at least for observers like us the only way to achieve this seems to be to progressively move structures across physical space. But to find out what can happen in the computational universe we can effectively just write down any rule (i.e. any program) that appears âanywhere in the ruliadâ, and run it.
Of course, when we run a rule on a practical computer, itâs just an emulation of whatâs happening in the raw ruliad. But itâs just an abstract ruleâso although it will run astronomically slower, its ultimate behavior in our emulation will inevitably be identical to what it is when implemented in terms of individual atoms of existence in the âraw ruliadâ.
In principle we could take the same approach in emulating the elements that make up our physical reality. But observers like us are so big relative to the raw elements of the ruliad that we canât expect our emulations to be at a scale where we can faithfully reproduce what we perceive. (Needless to say, in practice we can still get good approximations, and this is a particularly fertile application of our Physics Project.)
But when weâre dealing with âraw computationâ down at the lowest level of the raw ruliad, we can expect to faithfully emulate it. And so it is that we can just pick a cellular automaton or a Turing machine or some other kind of computational systemâthat in effect comes from anywhere in the ruliadâand emulate it to find out what it does. Thereâs no âobject we have to moveâ to be able to âlook at that part of the ruliadâ. Weâre emulating things down at the level of individual atoms of existence, and seeing what happens.
We can think about our computational experiments as letting us âjumpâ to find out what itâs like anywhere in the ruliad. And as we âsuddenly materializeâ somewhere in the ruliad itâs as if weâre immediately âface to faceâ with whatever âalien intelligenceâ there is at that place in the ruliad.
But what can âobservers like usâ expect to make of that alien intelligence? Well, to be able âcommunicateâ or even ârelateâ we somehow have to be able to âbridge the gap in rulial spaceâ. And since we just âjumped to a place in rulial spaceâ we donât immediately have any âprogressive pathâ that âincrementallyâ takes us from our familiar position in rulial space to wherever the alien intelligence is.
But what does that feel like in practice? The whole idea of ruliology is just to go anywhere we want in the computational universe or in the ruliad, and see what happens when we run the rules we find there. And itâs indeed routine to find that what they do seems quite âalienâ. Still, they often have certain essential features that for example remind us of the natural world as we observe it. But our standard methods of science (and mathematics)âdeveloped on the basis of being âobservers like we are todayââdonât readily allow us to âunderstandâ the behavior of these systems chosen in the course of doing ruliology. To us they usually just seem to be âshowing computational irreducibilityâ, and behaving in ways that we can effectively get no handle on.
But still, we can in a sense view these programs âout there in the computational universeâ (and in effect strewn around the ruliad) as showing us whatâs possible. Theyâre like alien intelligences that we know exist, but that we donât yet understand, and donât yet know how to harness or relate to. We can see them as some kind of beacons of possible technology of the futureâof things that âexist in the ruliadâ, but that we havenât yet been able to connect to human purposes.
But so how might we make this connection? Well, as it happens, Iâve devoted much of my life to what can be viewed as the construction of a systematic bridge between whatâs âcomputationally possibleâ and what we humans think of as important. For thatâs the story of what I call computational languageâand indeed of the whole intellectual structure that is the Wolfram Language.
Thereâs infinite potential content in the ruliad. But one can view the goal of the Wolfram Language as being to representâin a way thatâs optimized for us humans to understandâthose parts that we humans consider important. The language lets us use the concepts of computation not only to crystallize our existing thinking, but also to expand what we can think about, in effect letting us reach out further in rulial space. Computational language is the general way that we âtame the ruliadââextend the frontier of âhuman colonizationâ in the ruliad, and in the end âmineâ more and more of the ruliad for âuseful technologyâ.
Just in terms of its practical place in the world today Iâve often said that the Wolfram Language is like an âartifact from the futureâ. But now we see a deep sense in which this is true. The raw ruliad is just âout thereâ, with âinfinite potentialâ, but as something whose fundamental character has nothing to do with us humans. But what computational language is about is delivering what one can think of as the ultimate âmetaartifactâ: something that progressively turns the raw ruliad into âhumanrecognizable technologyâ.
Much of this progress involves the specific, systematic design of the Wolfram Language. But there are also forays that in effect jump further out into rulial space. For example, weâve often enumerated large collections of simple programs, identifying ones that satisfy a certain criterion. And sometimes that feels a lot like âleveraging alien intelligenceâ without âunderstandingâ it. The rule 30 cellular automaton, for example, is a good pseudorandom generator, even though we don’t really “understand” even fairly basic things about it.
And, yes, computational language is what we need to concretely âstate a criterionâ, in effect expressing what weâre thinking about in computational termsâthat we can use, for example, to let us explicitly search the ruliad for an âalien intelligenceâ that does what we want.
What does it look like out in the âraw ruliadâ? Itâs easy to start just looking at simple programs, say picked at random. And, yes, they have all sorts of elaborate behavior:
✕

But what is this behavior âachievingâ? Yes, itâs following the particular underlying rules that have been given. But we donât have any immediate way to connect it to âhuman purposesâ. And in general we can expect that to make that connection whatâs needed is for those purposes themselves to âexpandâ.
Maybe at some moment we call what’s produced “art”, and assign it some âaesthetic purposeâ. Maybe at some point we see that it satisfies some engineering purpose that weâve just realized we should care about. But in general, computational language is the way we can make the connection between âraw computational processesâ out there in the ruliad, and our patterns of thinking about things. Itâs the ultimate way for us to âcommunicate with alien intelligenceâ.
We began with the farout startup pitch of sending spacecraft to discover alien intelligence and bring its technology back to Earth. But what weâve realized is that actually no spacecraftâof the ordinary kindâare needed. Thereâs âalien intelligenceâ to be found everywhere; you donât have to travel to interstellar space to find it. But the challenge is to connect the âalien intelligenceâ to human purposes, and extract from it what we consider âuseful technologyâ. Or, put another way, the issue is not about traversing physical space, but rather about traversing rulial space.
With our spacecraft we humans have so far reached about a 20trillionth of the way across the physical universe. But no doubt weâve reached a far smaller fraction of the way across the ruliad. As our science, knowledge and technology increase, we gradually reach further into rulial space. But whether itâs our failure to communicate with cetaceans or our inability to make computers out of, say, fluids, itâs clear that by many measures the distance weâve gone so far is not so large.
In a sense the startup idea of âharnessing alien intelligenceâ is the metaidea of all technologyâthat in our terms we can state as being to connect whatâs âcomputationally possibleâ in the ruliad with purposes we humans want to achieve. And Iâve argued that the ultimate metatechnology for doing this is not spacecraft but computational language. Because computational language is what we need to make a bridge between what we care about, and âraw computationâ out in the ruliad.
Itâs difficult to send physical spacecraft out into interstellar space. But itâs actually a lot easier to probe the much richer possibilities of the ruliadâbecause in a sense itâs straightforward to put a ârulial spacecraftâ anywhere. We just have to pick a rule (or program), then see what the âworldâ it generates is. But the challenge is then in a sense one of interpretation. What is happening in that world? Can we relate it to things we care about?
At the outset, all weâre likely to see at some ârandom placeâ in the ruliad is rampant computational irreducibility. But itâs a fundamental fact that wherever thereâs computational irreducibility, there must also be slices of computational reducibility to be found. In the ordinary physical universe that we experience, those are basically our perceived laws of physics. But even in a random sample of the ruliad we can expect thereâll be computational reducibility to be found. Itâll typically be âalien stuffâ, though. It might have the character of science, but it wonât be like our existing science. And most likely it wonât align with anything we currently think we care about.
But that is the great challenge and promise of mounting a ârulial space programâ. To be confronted not with what we might recognize as ânew life and new civilizationsâ, but with things for which we have no description and no current way of thinking. Perhaps we might view it merely as humbling to encounter such things, and to realize how small a part of the ruliad we yet understand. But we can also view it as a beacon of where we could go. And we can view a whole ârulial space programâ as a way of systematizing the ultimate project of exploring all formally possible processes. Or we could think about it not just as defining a single âstartup opportunityââbut rather as defining the âmetaopportunityâ of all possible technology startups….
]]>Multicomputation is one of the core ideas of the Wolfram Physics Projectâand in particular is at the heart of our emerging understanding of quantum mechanics. But how can one get an intuition for what is initially the rather abstract idea of multicomputation? A good approach, I believe, is to see it in action in familiar systems and situations. And I explore here what seems like a particularly good example: games and puzzles.
One might not imagine that something as everyday as wellknown games and puzzles would have any connection to the formalism for something like quantum mechanics. But the idea of multicomputation provides a link. And indeed one can view the very possibility of being able to have âinterestingâ games and puzzles as being related to a core phenomenon of multicomputation: multicomputational irreducibility.
In an ordinary computational system each state of the system has a unique successor, and ultimately there is a single thread of time that defines a process of computation. But in a multicomputational system the key idea is that states can have multiple successorsâand tracing their behavior defines a whole multiway graph of branching and merging threads of time. And the point is that this is directly related to how one can think about typical games and puzzles.
Given a particular state of a game or puzzle, a player must typically decide what to do next. And where the idea of multicomputation comes in is that there are usually several choices that they can make. In any particular instance of the game, theyâll make a particular choice. But the point of the multicomputational paradigm is to look globally at the consequences of all possible choicesâand to produce a multiway graph that represents them.
The notion of making what we call a multiway graph has actually existedâusually under the name of âgame graphsââfor games and puzzles for a bit more than a hundred years. But with the multicomputational paradigm there are now some more general concepts that can be applied to these constructs. And in turn understanding the relation to games and puzzles has the potential to provide a new level of intuition and familiarity about multiway graphs.
My particular goal here is to investigateâfairly systematicallyâa sequence of wellknown games and puzzles using the general methods weâve been developing for studying multicomputational systems. As is typical in investigations that connect with everyday things, weâll encounter all sorts of specific details. And while these may not immediately seem relevant to largerscale discussions, they are important in our effort to provide a realistic and relatable picture of actual games and puzzlesâand in allowing the connections we make with multicomputation to be on a solid foundation.
Itâs worth mentioning that the possibility of relating games and puzzles to physics is basically something that wouldnât make sense without our Physics Project. For games and puzzles are normally at some fundamental level discreteâespecially in the way that they involve discrete branching of possibilities. And if one assumes physics is fundamentally continuous, thereâs no reason to expect a connection. But a key idea of our Physics Project is that the physical world is at the lowest level discreteâlike games and puzzles. And whatâs more, our Physics Project posits that physicsâlike games and puzzlesâhas discrete possibilities to explore.
At the outset each of the games and puzzles I discuss here may seem rather different in their structure and operation. But what weâll see is that when viewed in a multicomputational way, there is remarkableâand almost monotonousâuniformity across our different examples. I wonât comment too much on the significance of what we see until the end, when Iâll begin to discuss how various important multicomputational phenomena may play out in the context of games and puzzles. And how the very difficulty of conceptualizing multicomputation in straightforward human terms is what fundamentally leads to the engaging character of games and puzzles.
Consider a simplified version of tictactoe (AKA ânoughts and crossesâ) played on a 2Ă2 board. Assume X plays first. Then one can represent the possible moves by the graph:
✕

On the next turn one gets:
✕

So far this graph is a simple tree. But if we play another turn weâll see that different branches can merge, and âplaying until the board is fullâ we get a multiway graphâor “game graphââof the form:
✕

Every path through this graph represents a possible complete game:
✕

In our setup so far, the total number of board configurations that can ever be reached in any game (i.e. the total number of nodes in the graph) is 35, while the total number of possible complete games (i.e. the number of possible paths from the root of the graph) is 24.
If one renders the graph in 3D one can see that it has a very regular structure:
✕

And now if we define âwinningâ 2Ă2 tictactoe as having two identical elements in a horizontal row, then we can annotate the multiway graph to indicate winsâremoving cases where the âgame is already overâ:
✕

Much of the core structure of the multiway graph is actually already evident even in the seemingly trivial case of âoneplayer tictactoeâ, in which one is simply progressively filling in squares on the board:
✕

But what makes this not completely trivial is the existence of distinct paths that lead to equivalent states. Rendered differently the graph (which has 2^{4} = 16 nodes and 4! = 24 âgame pathsâ) has an obvious 4D hypercube form (where now we have dropped the explicit Xâs in each cell):
✕

For a 3Ă3 board the graph is a 9D hypercube with 2^{9} = 512 nodes and 9! = 362880 âgame pathsâ, or in âmovelayeredâ form:
✕

This basic structure is already visible in â1player 1D tictactoeâ in which the multiway graph for a âlengthnâ board just corresponds to an ndimensional hypercube:
✕

The total number of distinct board configurations in this case is just 2^{n}, and the number of distinct âgamesâ is n!. At move t the number of distinct board configurations (i.e. states) is Binomial[n, t].
With 2 players the graphs become slightly more complicated:
✕

The total number of states in these graphs is
✕

which is asymptotically . (Note that for n = 4 the result is the same as for the 2Ă2 board discussed above.) At move t the number of distinct states is given by
✕

✕

OK, so what about standard 2player 3Ă3 tictactoe? Its multiway graph begins:
✕

After 2 steps (i.e. one move by X and one by O) the graph is still a tree (with the initial state now at the center):
✕

After 3 steps there is starting to be merging:
✕

And continuing for all 9 moves the full layered graphâwith 6046 statesâis:
✕

At the level of this graph, the results are exactly the same as for a 2player 1D version with a total of 9 squares. But for actual 2D 3Ă3 tictactoe there is an additional element to the story: the concept of winning a game, and thereby terminating it. With the usual rules, a game is considered won when a player gets a horizontal, vertical or diagonal line of three squares, as in for example:
✕

Whenever a âwin stateâ such as these is reached, the game is considered over, so that subsequent states in the multiway graph are pruned, and what was previously a 6046node graph becomes a 5478node graph
✕

with examples of the 568 pruned states including (where the âwinâ that terminated the game is marked):
✕

Wins can occur at different steps: anywhere from 5 to 9. The total numbers of distinct wins are as follows
✕

(yielding 626 wins at any step for X and 316 for O).
One canât explicitly tell that a game has ended in a draw until every square has been filled inâand there are ultimately only 16 final âdraw configurationsâ that can be reached:
✕

We can annotate the full (âgameoverprunedâ) multiway graph, indicating win and draw states:
✕

To study this further, letâs start by looking at a subgraph that includes only âend gamesâ starting with a board that already has 4 squares filled in:
✕

We see here that from our initial board
✕

itâs possible to get a final win for both X and O:
✕

But in many of these cases the outcome is already basically determined a step or more before the actual win occursâin the sense that unless a given player âmakes a mistakeâ they will always be able to force a win.
So, for example, if it is X’s turn and the state is
✕

then X is guaranteed to win if they play as follows:
✕

We can represent the âpreforcingâ of wins by coloring subgraphs (or in effect âlight conesâ) in the multiway graph:
✕

At the very beginning of the game, when X makes the first move, nothing is yet forced. But after just one move, itâs already possible to get to configurations where X can always force a win:
✕

Starting from a state obtained after 1 step, we can see that after 2 steps there are configurations where O can force a win:
✕

Going to more moves leads to more âforcedwinâ configurations:
✕

Annotating the whole multiway graph we get:
✕

We can think of this graph as a representation of the âsolutionâ to the game: given any state the coloring in the graph tells us which player can force a win from that state, and the graph defines what moves they can make to do so.
Hereâs a summary of possible game states at each move:
✕

✕

Here weâre just counting the number of possible states of various kinds at each step. But is there a way to think about these states as somehow being laid out in âgame state spaceâ? Branchial graphs provide a potential way to do this. The basic branchial graph at a particular step is obtained by joining pairs of states that share a common ancestor on the step before. For the case of 2player 2Ă2 tictactoe the branchial graphs we get on successive steps are as follows:
✕

Things get more complicated for ordinary 3Ă3 tictactoe. But since the multiway graph for the first two steps is a pure tree, the branchial graphs at these steps still have a rather trivial structure:
✕

In general the number of connected components on successive steps is as follows
✕

and these are broken down across different graph structures as follows:
✕

Here in more detail are the forms of some typical components of branchial graphs achieved at particular steps:
✕

Within the branchial graph at a particular step, there can be different numbers of wins in different components:
✕

Itâs notable that the wins are quite broadly distributed across branchial graphs. And this is in a sense why tictactoe is not (more) trivial. If just by knowing what component of the branchial graph one was in one could immediately know the outcome, there would be even less âsuspenseâ in the game. But with broad distribution across branchial space, âknowing roughly where you areâ doesnât help much in determining whether youâre going to win.
So far weâve always been talking about what states can be reached, but not âhow oftenâ theyâre reached. Imagine that rather than playing a specific game, we instead at each step just make every possible move with equal probability. The setup for tictactoe is symmetrical enough that for most of the game the probability of every possible configuration at a given step is equal. But as soon as there start to be âwinsâ, and there is a âconeâ of âgameoverprunedâ states, then the remaining states no longer have equal probabilities.
For standard 3Ă3 tictactoe this happens after 7 moves, where there are two classes of states, that occur with slightly different probabilities:
✕

At the end of the game, there are several classes of final states with different probabilities:
✕

And what this means for the probabilities of different outcomes of the game is as follows:
✕

Not surprisingly, the player who plays first has an advantage in winning. Perhaps more surprising is that in this kind of âstrategylessâ play, ties are comparatively uncommonâeven though if one player actively tries to block the other, they often force a tie.
Weâve looked at âclassic tictactoeâ and a few specific variants. But there are ultimately all sorts of possible variants. And a convenient general way to represent the âboardâ for any tictactoelike game is just to give a âflattenedâ list of valuesâwith 0 representing a blank position, and i representing a symbol added by player i.
In standard â2D representationâ one might have a board like
✕

which in flattened form would be:
✕

Typical winning patterns can then be represented
✕

where in each case we have framed the relevant âwinning symbolsâ, and then given their positions in the flattened list. In ordinary tictactoe itâs clear that the positions of âwinning symbolsâ must always form an arithmetic progression. And it seems as if a good way to generalize tictactoe is always to define a win for i to be associated with the presence of i symbols at positions that form an arithmetic progression of a certain length s. For ordinary tictactoe s = 3, but for generalizations it could have other values.
Consider now the case of a length5 list (i.e. 5position â1D boardâ). The complete multiway graph is as follows, with âwinning statesâ that contain arithmetic progressions of length s = 3 highlighted:
✕

In a more symmetrical rendering this is:
✕

Hereâs the analogous result for a 7position board, and 2 players:
✕

For each size of board n, we can compute the total number of winning states for any given player, as well as the total number of states altogether. The result when winning is based on arithmetic progressions of length 3 (i.e. s = 3) is:
✕

The 2player n = 9 (= 3Ă3) case here is similar to ordinary tictactoe, but not the same. In particular, states like
✕

are considered wins for X in the flattened setup, but not in ordinary tictactoe.
If we increase the length of progression needed in order to declare a win, say to s = 4, we get:
✕

The total number of game states is unchanged, butâas expectedâthere are âfewer ways to winâ.
But letâs say we have boards that are completely filled in. For small board sizes there may well not be an arithmetic progression of positions for any playerâso that the game has to be considered a tieâas we see in this n = 5 case:
✕

But it is a result related to Ramsey theory that it turns out that for n â„ 9, itâs inevitable that there will be an âarithmetic progression winâ for at least one of the playersâso that there is never a tieâas these examples illustrate:
✕

A game like tictactoe effectively involves at each step moving to one of several possible new board configurationsâwhich we can think of as being at different âplacesâ in âgame state spaceâ. But what if instead of board configurations we just consider our states to be positions on a lattice such as
✕

and then we look at possible walks, that at each step can, in this case, go one unit in any of 4 directions?
Starting at a particular point, the multiway graph after 1 step is just
✕

where we have laid out this graph so that the âstatesâ are placed at their geometrical positions on the lattice.
After 2 steps we get:
✕

And in general the structure of the multiway graph just ârecapitulatesâ the structure of the lattice:
✕

We can think of the paths in the multiway graph as representing all possible random walks of a certain length in the lattice. We can lay the graph out in 3D, with the vertical position representing the first step at which a given point can be reached:
✕

We can also lay out the graph more like we laid out multiway graphs for tictactoe:
✕

One feature of these ârandomwalkâ multiway graphs is that they contain loops, that record the possibility of âreturning to places oneâs already beenâ. And this is different from what happens for example in tictactoe, in which at each step one is just adding an element to the board, and itâs never possible to go back.
But we can set up a similar ânevergoback ruleâ for walks, by considering âselfavoiding walksâ in which any point thatâs been visited can never be visited again. Letâs consider first the very trivial lattice:
✕

Now indicate the âcurrent place weâve reachedâ by a blue dot, and the places weâve visited before by red dotsâand start from one corner:
✕

There are only two possible walks here, one going clockwise, the other counterclockwise. Allowing one to start in each possible position yields a slightly more complicated multiway graph:
✕

With a 2Ă3 grid we get
✕

while with a 3Ă3 grid we get:
✕

Starting in the center, and with a different layout for the multiway graph, we get:
✕

Note the presence of large âholesâ, in which paths on each side basically âget to the same placeâ in âopposite waysâ. Note that of the 2304 possible ways to have 1 blue dot and up to 8 red ones, this actual multiway graph reaches only 57. (Starting from the corner reaches 75 and from all possible initial positions 438.)
With a 4Ă4 lattice (starting the walker in the corner) the multiway graph has the form
✕

or in an alternative layout
✕

where now 1677 states out of 524,288 are eventually visited, and the number of new states visited at each step (i.e. the number of nodes in successive layers in the graph) is:
✕

For a 5Ă5 grid 89,961 states are reached, distributed across steps according to:
✕

(For a grid with n vertices, there are a total of n 2^{nâ1} possible states, but the number actually reached is always much smaller.)
In talking about walks, an obvious question to ask is about mazes. Consider the maze:
✕

As far as traversing this maze is concerned, it is equivalent to âwalkingâ on the graph
✕

which in another embedding is just
✕

But just as before, the multiway graph that represents all possible walks essentially just ârecapitulatesâ this graph. And that means that âsolvingâ the maze can in a sense equally be thought of as finding a path directly in the maze graph, or in the multiway graph:
✕

Our discussion of selfavoiding walks turns out to be immediately related to the âIcosian gameâ of William Rowan Hamilton from 1857 (which is somewhat related to the early computer game Hunt the Wumpus):
The object of the âgameâ (or, more properly, puzzle) is to find a path (yes, a Hamiltonian path) around the icosahedron graph that visits every node (and returns back to where it started from). And once again we can construct a multiway graph that represents all possible sequences of âmovesâ in the game.
Letâs start with the simpler case of an underlying tetrahedron graph:
✕

From this we get the multiway graph:
✕

The âcombined multiway graphâ from all possible starting positions on the tetrahedron graph gives a truncated cuboctahedron multiway graph:
✕

And following this graph we see that from any initial state itâs always possible to reach a state where every node in the tetrahedron graph has been visited. In fact, because the tetrahedron graph is a complete graph itâs even guaranteed that the last node in the sequence will be âadjacentâ to the starting nodeâso that one has formed a Hamiltonian cycle and solved the puzzle.
Things are less trivial for the cube graph:
✕

The multiway graph (starting from a particular state) in this case is:
✕

Now there are 13 configurations where no further moves are possible:
✕

In some of these, oneâs effectively âboxed inâ with no adjacent node to visit. In others, all the nodes have been filled in. But only 3 ultimately achieve a true Hamiltonian cycle that ends adjacent to the starting node:
✕

It turns out that one can reach each of these states through 4 distinct paths from the root of the multiway graph. An example of such a path is:
✕

We can summarize this path as a Hamiltonian circuit of the original cube graph:
✕

In the multiway graph, the 12 âwinning pathsâ are
✕

In a different rendering this becomes
✕

and keeping only âwinning pathsâ the subgraph of the multiway graph has the symmetrical form:
✕

The actual Hamiltonian circuits through the underlying cube graph corresponding to these winning paths are:
✕

For the dodecahedral graph (i.e. the original Icosian game), the multiway graph is larger and more complicated. It begins
✕

and has its first merge after 11 steps (and 529 in all), and ends up with a total of 11,093 nodesâof which 2446 are âend statesâ where no further move is possible. This shows the number of end (below) and nonend (above) states at each successive step:
✕

The successive fractions of âontracktosucceedâ states are as follows, indicating that the puzzle is in a sense harder at the beginning than at the end:
✕

There are 13 âend statesâ which fill in every position of the underlying dodecahedral graph, with 3 of these corresponding to Hamiltonian cycles:
✕

The total number of paths from the root of the multiway graph leading to end states (in effect the total number of ways to try to solve the puzzle) is 3120. Of these, 60 lead to the 3 Hamiltonian cycle end states. An example of one of these âwinning pathsâ is:
✕

Examples of underlying Hamiltonian cycles corresponding to each of the 3 Hamiltonian cycle end states are:
✕

And this now shows all 60 paths through the multiway graph that reach Hamiltonian cycle end statesâand thus correspond to solutions to the puzzle:
✕

In effect, solving the puzzle consists in successfully finding these paths out of all the possibilities in the multiway graph. In practice, thoughâmuch as in theoremproving, for exampleâthere are considerably more efficient ways to find âwinning pathsâ than to look directly at all possibilities in the multiway graph (e.g. FindHamiltonianCycle in Wolfram Language). But for our purpose of understanding games and puzzles in a multicomputational framework, itâs useful to see how solutions to this puzzle lay out in the multiway graph.
The Icosian game from Hamilton was what launched the idea of Hamiltonian cycles on graphs. But already in 1736 Leonhard Euler had discussed what are now called Eulerian cycles in connection with the puzzle of the Bridges of KĂ¶nigsberg. In modern terms, we can state the puzzle as the problem of finding a path that visits once and only once all the edges in the graph (in which the âdouble bridgesâ from the original puzzle have been disambiguated by extra nodes):
✕

We can create a multiway graph that represents all possible paths starting from a particular vertex:
✕

But now we see that the end states here are
✕

and since none of them have visited every edge, there is no Eulerian circuit here. To completely resolve the puzzle we need to make a multiway graph in which we start from all possible underlying vertices. The result is a disconnected multiway graph whose end states again never visit every edge in the underlying graph (as one can tell from the fact that the number of âlevelsâ in each subgraph is less than 10):
✕

In the Geography Game one has a collection of words (say place names) and then one attempts to âstring the words togetherâ, with the last letter of one word being the same as the first letter of the next. The game typically ends when nobody can come up with a word that works and hasnât been used before.
Usually in practice the game is played with multiple players. But one can perfectly well consider a version with just one player. And as an example letâs take our âwordsâ to be the abbreviations for the states in the US. Then we can make a graph of what can follow what:
✕

Letâs at first ignore the question of whether a state has âalready been usedâ. Then, starting, say, from Massachusetts (MA), we can construct the beginning of a multiway graph that gives us all possible sequences:
✕

After 10 steps the graph is
✕

or in a different rendering:
✕

This shows the total number of paths as a function of length through this graph, assuming one doesnât allow any state to be repeated:
✕

The maximum length of path is 23âand there are 256 such paths, 88 ending with TX and 168 ending with AZ. A few sample such paths are
✕

and all these paths can be represented by what amounts to a finite state machine:
✕

By the way, the starting state that leads to the longest path is MNâwhich achieves length 24 in 2336 different ways, with possible endings being AZ, DE, KY and TX. A few samples are:
✕

Drawing these paths in the first few steps of the multiway graph starting from MN we get:
✕

Weâve talked about puzzles that effectively involve walks on graphs. A particularly famous example of a puzzle that can be thought about in this way is the Rubikâs Cube. The graph in question is then the Cayley graph for the group formed by the transformations that can be applied to the cube.
As a very simple analog, we can consider the symmetry group of the square, D_{4}, based on the operations of reflection and 90Â° rotation. We generate the Cayley graph just like a multiway graph: by applying each operation at each step. And in this example the Cayley graph is:
✕

This graph is small enough that it is straightforward to see how to get from any configuration to any other. But while this Cayley graph has 8 nodes and maximum path length from any one node to any other of 3, the Cayley graph for the Rubik’s Cube has nodes and a maximum shortest path length of 20.
To get some sense of the structure of an object like this, we can consider the very simplified case of a â2Ă2Ă2 cubeââcolored only on its cornersâin which each face can be rotated by 90Â°:
✕

The first step in the multiway graphâstarting from the configuration aboveâis then (note that the edges in the graph are not directed, since the underlying transformations are always reversible):
✕

Going another step gives:
✕

The complete multiway graph (which is also the Cayley graph for the groupâwhich turns out to be S_{8}âgenerated by the transformations) has 8! = 40,320 nodes (and 483,840 edges). Starting from a state (i.e. node in the Cayley graph) the number of new states reached at successive steps is:
✕

The maximum shortest paths in the graph consist of 8 steps; an example is:
✕

Between these particular two endpoints there are actually 3216 âgeodesicâ pathsâwhich spread out quite far in the multiway graph
✕

Picking out only geodesic paths we see there are many ways to get from one configuration of the cube to one of its âantipodesâ:
✕

Whereas something like tictactoe involves progressively filling in a board, a large class of puzzles that have been used since at least the 1600s involve basically removing pegs from a board. The typical rules involve pegs being able to jump over a single intermediate peg into a hole, with the intermediate peg then being removed. The goal is to end up with just a single peg on the board.
Hereâs a very simple example based on a T arrangement of pegs:
✕

In this case, thereâs only one way to âsolve the puzzleâ. But in general thereâs a multiway graph:
✕

A more complicated example is the âTricky Triangleâ (AKA the âCracker Barrel puzzleâ). Its multiway graph begins:
✕

After another couple of steps it becomes:
✕

There are a total of 3016 states in the final multiway graph, of which 118 are âdeadendâ configurations from which no further moves are possible. The âearliestâ of these deadend configurations are:
✕

There are just 4 âwinning statesâ that can be reached, and the âend gamesâ that lead to them are:
✕

Starting from the initial configuration, the number of possible states reached at each step is given as follows, where the states that can lead to winning configurations is shown in yellow:
✕

This shows the complete multiway graph, with âwinning pathsâ highlighted:
✕

At successive steps, the fraction of states that can lead to a winning state is as follows:
✕

The branchial graphs are highly connected, implying that in a sense the puzzle remains âwell mixedâ and âunpredictableâ until the very end:
✕

Peg solitaire is a oneplayer âgameâ. Checkers (AKA draughts) is a twoplayer game with a somewhat similar setup. âBlackâ and âredâ pieces move diagonally in different directions on a board, âtakingâ each other by jumping over when they are adjacent.
Letâs consider the rather minimal example of a 4Ă4 board. The basic set of possible moves for âblackâ and âredâ is defined by the graphs (note that a 4Ă4 board is too small to support âmultiple jumpsâ):
✕

With this setup we can immediately start to generate a multiway graph, based on alternating black and red moves:
✕

With the rules as defined so far, the full 161node multiway graph is:
✕

Itâs not completely clear what it means to âwinâ in this simple 4Ă4 case. But one possibility is to say that it happens when the other player canât do anything at their next move. This corresponds to âdead endsâ in the multiway graph. There are 26 of these, of which only 3 occur when it is redâs move next, and the rest all occur when it is blackâs move:
✕

As before, any particular checkers game corresponds to a path in the multiway graph from the root to one of these end states. If we look at branchial graphs in this case, we find that they have many disconnected pieces, indicating that there are many largely independent âgame pathsâ for this simple game—so there is not much âmixingâ of outcomes:
✕

✕

The rules weâve used so far donât account for what amounts to the second level of rules for checkers: the fact that when a piece reaches the other side of the board it becomes a âkingâ thatâs allowed to move backwards as well as forwards. Even with a single piece and single player this already generates a multiway graphânotably now with loops:
✕

or in an alternative layout (with explicitly undirected edges):
✕

With two pieces (and two players taking turns) the âkingsâ multiway graph begins:
✕

With this initial configuration, but without backward motion, the whole multiway graph is just:
✕

The full âkingsâ multiway graph in this case also only has 62 nodesâbut includes all sorts of loops (though with this few pieces and black playing first itâs inevitable that any win will be for black):
✕

What about the ordinary + kings multiway graph from our original initial conditions? The combined graph has 161 nodes from the âprekingâ phase, and 4302 from the âpostkingâ phaseâgiving the final form:
✕

The full game of Go is sophisticated and its multiway graph in any realistic case is far too big for us to generate at all explicitly (though one can certainly wonder if there are meaningful âcontinuum limitâ results). However, to get some flavor of Go we can consider a vastly simplified version in which black and white âstonesâ are progressively placed on nodes of a graph, and the game is considered âwonâ if one player has successfully surrounded a connected collection of the other playerâs stones.
Imagine that we start with a blank âboardâ consisting of a 2Ă2 square of positions, then on a sequence of âturnsâ add black and white stones in all possible ways. The resulting multiway graph is:
✕

Every state that has no successor here is a win for either black or white. The âblack winsâ (with the surrounded stone highlighted) are
✕

while the âwhite winsâ are:
✕

At this level what we have is basically equivalent to 2Ă2 tictactoe, albeit with a âdiagonalâ win condition. With a 3Ă2 âboardâ, the first two steps in the multiway graph are:
✕

The final multiway graph is:
✕

The graph has 235 nodes, of which 24 are wins for white, and 34 for black:
✕

The successive branchial graphs in this case are (with wins for black and white indicated):
✕

For a 3Ă3 âboardâ the multiway graph has 5172 states, with 604 being wins for white and 684 being wins for black.
As another example of a simple game, weâll now consider Nim. In Nim, there are k piles of objects, and at each step p players alternate in removing as many objects as they want from whatever single pile they choose. The loser of the game is the player who is forced to have 0 objects in all the piles.
Starting off with 2 piles each containing 2 objects, one can construct a multiway graph for the game:
✕

With 3 piles this becomes:
✕

These graphs show all the different possible moves that relate different configurations of the piles. However, they do not indicate which player moves when. Adding this we get in the 22 case
✕

and in the 222 case:
✕

Even though these graphs look somewhat complicated, it turns out there is a very straightforward criterion for when a particular state has the property that its âopponentâ can force a lose: just take the list of numbers and see if Apply[BitXor, list] is 0. Highlighting when this occurs we get:
✕

It turns that for Nim, the sequence of branchial graphs we get have a rather regular structure. In the 22 case, with the same highlighting as before, we get:
✕

In the 222 case the sequence of branchial graphs becomes:
✕

Here are results for some other cases:
✕

They go under many namesâwith many different kinds of theming. But many puzzles are ultimately sliding block puzzles. A simple example might ask to go from
✕

by sliding blocks into the empty (darker) square. A solution to this is:
✕

One can use a multiway graph to represent all possible transformations:
✕

(Note that only 12 of the 4! = 24 possible configurations of the blocks appear here; a configuration like cannot be reached.)
Since blocks can always be âslid both waysâ every edge in a slidingblockpuzzle multiway graph has an inverseâso going forward weâll just draw these multiway graphs as undirected.
Here are some simple cases:
✕

✕

With a 3Ă2 board, things quickly get more complicated:
✕

Rendered in 3D this becomes:
✕

When all the blocks are distinct, one tends to get multiway graphs with a kind of spherical structure:
✕

(Note that in the first three cases here, itâs possible to reach all 30, 120, 360 conceivable arrangements of the blocks, while in the last case one can only reach âeven permutationsâ of the blocks, or 360 of the 720 conceivable arrangements.)
This shows how one gets from to :
✕

With many identical blocks one tends to build up a simple lattice:
✕

Making one block different basically just âadds decorationâ:
✕

As the number of â1â and â2â blocks becomes closer to equal, the structure fills in:
✕

Adding a third type of block rapidly leads to a very complicated structure:
✕

This summarizes a few of the graphs obtained:
✕

✕

Another wellknown puzzle is the Towers of Hanoi. And once again we can construct a multiway graph for it. Starting with all disks on the left peg the first step in the multiway graph is:
✕

Going two steps we get:
✕

The complete multiway graph is then (showing undirected edges in place of pairs of directed edges):
✕

It is rather easy to see how the recursive structure of this multiway graph builds up. Hereâs the âbase caseâ of 2 disks (and 3 pegs):
✕

And as each disk is added, the number of nodes in the multiway graph increases by a factor of 3âyielding for example with 4 disks (and still 3 pegs):
✕

With 4 pegs, things at first look more complicated, even with 2 disks:
✕

In a 3D rendering, more structure begins to emerge:
✕

And here are the results for 3, 4 and 5 disksâwith the âpoints of the earsâ corresponding to states where all the disks are on a single peg:
✕

With 3 pegs, the shortest âsolution to the puzzleââof moving all disks from one peg to anotherâgoes along the âsideâ of the multiway graph, and for n pegs is of length 2^{n} â 1:
✕

With 4 pegs, there is no longer a unique âgeodesic pathâ:
✕

(And the sequence of path lengths for successive numbers of pegs is
✕

or a little below for a large number of pegs n.)
What about branchial graphs? For the standard 3disk 3peg case we have
✕

where successive âtime slicesâ are assumed to be obtained by looking at successive vertical levels in the rendering of the multiway graph above.
For 4 disks one essentially gets âmore of the sameâ:
✕

With 4 pegs things become slightly more complicated:
✕

And the trend continues for 5 pegs:
✕

Weâve now gone through many examples of games and puzzles. And in each case weâve explored the multiway graphs that encapsulate the whole spectrum of their possible behavior. So what do we conclude? The most obvious point is that when games and puzzles seem to us difficultâand potentially âinterestingââitâs some kind of reflection of apparent complexity in the multiway graph. Or, put another way, itâs when we find the multiway graph somehow âdifficult to decodeâ that we get a rich and engaging game or puzzle.
In any particular instance of playing a game weâre basically following a specific path (that in analogy to physics we can call a âtimelike pathâ) through the multiway graph (or âgame graphâ) for the game. And at some level we might just make the global statement that the game graph represents all such paths. But what the multicomputational paradigm suggests is that there are also more local statements that we can usefully make. In particular, at every step along a timelike path we can look âtransversallyâ in the multiway graph, and see the âinstantaneous branchial graphâ that represents the âentanglementâ of our path with ânearby pathsâ.
Figuring out âwhat move to make nextâ is then in a sense about deciding in âwhat directionâ in branchial space to go. And what makes a game difficult is that we canât readily predict what happens as we âtravel through branchial spaceâ. Thereâs a certain analogy here to the concept of computational irreducibility. Going from one state to another along some timelike path, computational irreducibility implies that even though we may know the underlying rules, we canât readily predict their consequencesâbecause it can require an irreducible amount of computation to figure out what their consequences will be after many steps.
Predicting âacross branchial spaceâ is a related, but slightly different phenomenon, that one can describe as âmulticomputational irreducibilityâ. Itâs not about the difficulty of working out a particular path of computation, but instead about the difficulty of seeing how many entangled paths interact.
When one plays a game, itâs common to talk about âhow many moves ahead one can seeâ. And in our terms here, this is basically about asking how âfar out in branchial spaceâ we can readily get. As computationally bounded entities, we have a certain âreachâ in branchial space. And the game is âdifficult for usâ if that reach isnât sufficient to be able to get to something like a âwinning positionâ.
Thereâs another point here, though. What counts as âwinningâ in a game is typically reaching some particular places or regions in the multiway graph. But the definition of these places or regions is typically something very computationally bounded (âjust see if thereâs a line of Xâsâ, etc.). Itâs a certain âobservationâ of the system, that extracts just a particular (computationally bounded) sampling of the complete state. And then whatâs key is that this sampling doesnât manage to âdecode the multicomputational irreducibilityâ.
Thereâs an analogy here to thermodynamics. The fact that in thermodynamics we perceive âheatâ and âentropy increaseâ is a consequence of the fact that our (coarsegrained) measurements canât “decode” the computationally irreducible process that leads to the particular states generated in the system. Similarly, the fact we perceive it to be âhard to figure out how to win a gameâ is a consequence of the fact that our criterion for winning isnât able to âlook inside the playing of the gameâ and âdecode whatâs going onâ to the point where itâs in effect just selecting one particular, straightforward path. Instead itâs a question of going through the multicomputationally irreducible process of playing the game, and in effect âseeing where it landsâ relative to the observation of winning.
Thereâs also an analogy here to quantum mechanics. Tracing through many possible paths of playing a game is like following many threads of history in quantum mechanics, and the criterion of winning is like a quantum measurement that selects certain threads. In our Physics Project we imagine that we as observers are extended in branchial space, âknitting togetherâ different threads of history through our belief in our own single thread of experience. In games, the analog of our belief in a single thread of experience is presumably in effect that âall that matters is who wins or loses; it doesnât matter how the game is played insideâ.
To make a closer analogy with quantum mechanics one can start thinking about combining different chunks of âmultiway game playâ, and trying to work out a calculus for how those chunks fit together.
The games weâve discussed here are all in a sense pure âgames of skillâ. But in games where thereâs also an element of chance we can think of this as causing what is otherwise a single path in the multiway graph to âfuzz outâ into a bundle of paths, and what is otherwise a single point in branchial space to become a whole extended region.
In studying different specific games and puzzles, weâve often had to look at rather simplified cases in order to get multiway graphs of manageable size. But if we look at very large multiway graphs, are there perhaps overall regularities that will emerge? Is there potentially some kind of âcontinuum limitâ for game graphs?
Itâll almost inevitably be the case that if we look in âenough detailâ weâll see all sorts of multicomputational irreducibility in action. But in our Physics Projectâand indeed in the multicomputational paradigm in generalâa key issue is that relevant observers donât see that level of detail. And much like the emergence of thermodynamics or the gas laws from underlying molecular dynamics, the very existence of underlying computational irreducibility inevitably leads to simple laws for what the observer can perceive.
So what is the analog of âthe observerâ for a game? For at least some purposes it can be thought of as basically the âwinâ criteria. So now the question arises: if we look only at these criteria, can we derive the analog of âlaws of physicsâ, insensitive to all the multicomputationally irreducible details underneath?
Thereâs much more to figure out about this, but perhaps one place to start is to look at the largescale structure of branchial spaceâand the multiway graphâin various games. And one basic impression in many different games is thatâwhile the character of branchial graphs may change between âdifferent stagesâ in the gameâacross a single branchial graph there tends to be a certain uniformity. If one looks at the details there may be plenty of multicomputational irreducibility. But at some kind of âperceptible levelâ different parts of the graph may seem similar. And this suggests that the âlocal impression of the gameâ will tend to be similar at a particular stage even when quite different moves have been made, that take one to quite different parts of the âgame spaceâ defined by the branchial graph.
But while there may be similarity between different parts of the branchial graph, what weâve seen is that in some games and puzzles the branchial graph breaks up into multiple disconnected regions. And what this reflects is the presence of distinct âconserved sectorsâ in a gameâregions of game space that players can get into, but are then stuck with (at least for a certain time), much as in spacetime event horizons can prevent transport between different regions of physical space.
Another (related) effect that we notice in some games and puzzles but not others is large âholesâ in the multiway graph: places where between two points in the graph there are multiple âdistantâ paths. When the multiway graph is densely connected, thereâll typically always be a way to âfix any mistakeâ by rerouting through nearby paths. But when there is a hole it is a sign that one can end up getting âcommittedâ to one course of action rather than another, and it will be many steps before itâs possible to get to the same place as the other course of action would have reached.
If we assume that at some level all we ultimately âobserveâ in the multiway graph is the kind of coarsegraining that corresponds to assessing winning or losing then inevitably weâll be dealing with a distribution of possible paths. Without âholesâ these paths can be close together, and may seem obviously similar. But when thereâs a hole there can be different paths that are far apart. And the fact there can be distant paths that are âpart of the same distributionâ can then potentially be thought of as something like a quantum superposition effect.
Are there analogs of general relativity and the path integral in games? To formulate this with clarity weâd have to define more carefully the character of âgame spaceâ. Presumably thereâll be the analog of a causal graph. And presumably thereâll also be an analog of energy in game space, associated with the âdensity of activityâ at different places in game space. Then the analog of the phenomenon of gravity will be something like that the best game plays (i.e. the geodesic paths through the game graph) will tend to be deflected by the presence of high densities of activity. In other words, if there are lots of things to do when a game is in a certain state, good game plays will tend to be âpulled towards that stateâ. And at some level this isnât surprising: when thereâs high density of activity in the game graph, there will tend to be more options about what to do, so itâs more likely that one will be able to âdo a good game playâ if one goes through there.
So far we didnât explicitly talk about strategies for games. But in our multicomputational framework a strategy has a fairly definite interpretation: it is a place in rulial space, where in effect oneâs assuming a certain set of rules about how to construct the multiway graph. In other words, given a strategy one is choosing some edges in the multiway graph (or some possible events in the associated multiway causal graph), and dropping others.
In general it can be hard to talk about the âspace of possible strategiesââbecause itâs like talking about the âspace of possible programsâ. But this is precisely what rulial space lets us talk about. What exact âgeometryâ the âspace of strategiesâ has will depend on how we choose to coordinatize rulial space. But once again there will tend to be a certain level of coarsegraining achieved by looking only at the kinds of things one discusses in game theoryâand at this level we can expect that all sorts of standard âstructuralâ gametheoretic results will generically hold.
Even as a kid I was never particularly into playing games or doing puzzles. And maybe itâs a sign I was always a bit too much of a scientist. Because just picking specific moves always seemed to me too arbitrary. To get my interest I needed a bigger picture, more of a coherent intellectual story. But now, in a sense, thatâs just what the multicomputational approach to games and puzzles that I discuss here is bringing to us. Yes, itâs very âhumanizingâ to be able think about making particular moves. But the multicomputational approach immediately gives one a coherent global view that, at least to me, is intellectually much more satisfying.
The explorations Iâve discussed here can be thought of as originating from a single note in A New Kind of Science. In Chapter 5 of A New Kind of Science I had a section where I first introduced multiway systems. And as the very last note for that section I discussed “Game systems”:
✕

I did the research for this in the 1990sâand indeed I now find a notebook from 1998 about tictactoe with some of the same results derived here
✕

together with a curiouslooking graphical representation of the tictactoe game graph:
✕

But back at that time I didnât conclude much from the game graphs I generated; they just seemed large and complicated. Twenty years passed and I didnât think much more about this. But then in 2017 my son Christopher was playing with a puzzle called Rush Hour:
And perhaps in a sign of familial tendency he decided to construct its game graphâcoming up with what to me seemed like a very surprising result:
✕

At the time I didnât try to understand the structure one has hereâbut I still âfiled this awayâ as evidence that game graphs can have âvisible largescale structureâ.
A couple of years laterâin late 2019âour Physics Project was underway and weâd realized that there are deep relations between quantum mechanics and multiway graphs. Quantum mechanics had always seemed like something mysteriousâthe abstract result of pure mathematical formalism. But seeing the connection to multiway systems began to suggest that one might actually be able to âunderstand quantum mechanicsâ as something that could âmechanically ariseâ from some concrete underlying structure.
I started to think about finding ways to explain quantum mechanics at an intuitive level. And for that I needed a familiar analogy: something everyday that one could connect to multiway systems. I immediately thought about games. And in September 2020 I decided to take a look at games to explore this analogy in more detail. I quickly analyzed games like tictactoe and Nimâas well as simple sliding block puzzles and the Towers of Hanoi. But I wanted to explore more games and puzzles. And I had other projects to do, so the multicomputational analysis of games and puzzles got set aside. The Towers of Hanoi reappeared earlier this year, when I used it as an example of generating a prooflike multiway graph, in connection with my study of the physicalization of metamathematics. And finally, a few weeks ago I decided it was time to write down what I knew so far about games and puzzlesâand produce whatâs here.
Thanks to Brad Klee and Ed Pegg for extensive help in the final stages of the analysis given hereâas well as to Christopher Wolfram for inspiration in 2017, and help in 2020.
]]>When A New Kind of Science was published twenty years ago I thought what it had to say was important. But what’s become increasingly clearâparticularly in the last few yearsâis that it’s actually even much more important than I ever imagined. My original goal in A New Kind of Science was to take a step beyond the mathematical paradigm that had defined the state of the art in science for three centuriesâand to introduce a new paradigm based on computation and on the exploration of the computational universe of possible programs. And already in A New Kind of Science one can see that there’s immense richness to what can be done with this new paradigm.
Thereâs a new abstract basic scienceâthat I now call ruliologyâthatâs concerned with studying the detailed properties of systems with simple rules. Thereâs a vast new source of âraw materialâ to âmineâ from the computational universe, both for making models of things and for developing technology. And there are new, computational ways to think about fundamental features of how systems in nature and elsewhere work.
But whatâs now becoming clear is that thereâs actually something still bigger, still more overarching that the paradigm of A New Kind of Science lays the foundations for. In a sense, A New Kind of Science defines how one can use computation to think about things. But what weâre now realizing is that actually computation is not just a way to think about things: it is at a very fundamental level what everything actually is.
One can see this as a kind of ultimate limit of A New Kind of Science. What we call the ruliad is the entangled limit of all possible computations. And what we, for example, experience as physical reality is in effect just our particular sampling of the ruliad. And itâs the ideas of A New Kind of Scienceâand particularly things like the Principle of Computational Equivalenceâthat lay the foundations for understanding how this works.
When I wrote A New Kind of Science I discussed the possibility that there might be a way to find a fundamental model of physics based on simple programs. And from that seed has now come the Wolfram Physics Project, which, with its broad connections to existing mathematical physics, now seems to show that, yes, it’s really true that our physical universe is âcomputational all the way downâ.
But there’s more. It’s not just that at the lowest level there’s some specific rule operating on a vast network of atoms of space. It’s that underneath everything is all possible computation, encapsulated in the single unique construct that is the ruliad. And what determines our experienceâand the science we use to summarize itâis what characteristics we as observers have in sampling the ruliad.
There is a tower of ideas that relate to fundamental questions about the nature of existence, and the foundations not only of physics, but also of mathematics, computer science and a host of other fields. And these ideas build crucially on the paradigm of A New Kind of Science. But they need something else as well: what I now call the multicomputational paradigm. There were hints of it in A New Kind of Science when I discussed multiway systems. But it has only been within the past couple of years that this whole new paradigm has begun to come into focus. In A New Kind of Science I explored some of the remarkable things that individual computations out in the computational universe can do. What the multicomputational paradigm now does is to consider the aggregate of multiple computationsâand in the end the entangled limit of all possible computations, the ruliad.
The Principle of Computational Equivalence is in many ways the intellectual culmination of A New Kind of Scienceâand it has many deep consequences. And one of them is the ideaâand uniquenessâof the ruliad. The Principle of Computational Equivalence provides a very general statement about what all possible computational systems do. What the ruliad then does is to pull together the behaviors and relationships of all these systems into a single object that is, in effect, an ultimate representation of everything computational, and indeed in a certain sense simply of everything.
The publication of A New Kind of Science 20 years ago was for me already the culmination of an intellectual journey that had begun more than 25 years earlier. I had started in theoretical physics as a teenager in the 1970s. And stimulated by my needs in physics, I had then built my first computational language. A couple of years later I returned to basic science, now interested in some very fundamental questions. And from my blend of experience in physics and computing I was led to start trying to formulate things in terms of computation, and computational experiments. And soon discovered the remarkable fact that in the computational universe, even very simple programs can generate immensely complex behavior.
For several years I studied the basic science of the particular class of simple programs known as cellular automataâand the things I saw led me to identify some important general phenomena, most notably computational irreducibility. Then in 1986âhaving âanswered most of the obvious questions I could seeââI left basic science again, and for five years concentrated on creating Mathematica and whatâs now the Wolfram Language. But in 1991 I took the tools Iâd built, and again immersed myself in basic science. The decade that followed brought a long string of exciting and unexpected discoveries about the computational universe and its implicationsâleading finally in 2002 to the publication of A New Kind of Science.
In many ways, A New Kind of Science is a very complete bookâthat in its 1280 pages does well at âanswering all the obvious questionsâ, save, notably, for some about the âapplication areaâ of fundamental physics. For a couple of years after the book was published, I continued to explore some of these remaining questions. But pretty soon I was swept up in the building of WolframAlpha and then the Wolfram Language, and in all the complicated and often deep questions involved in for the first time creating a fullscale computational language. And so for nearly 17 years I did almost no basic science.
The ideas of A New Kind of Science nevertheless continued to exert a deep influenceâand I came to see my decades of work on computational language as ultimately being about creating a bridge between the vast capabilities of the computational universe revealed by A New Kind of Science, and the specific kinds of ways we humans are able to think about things. This point of view led me to all kinds of important conclusions about the role of computation and its implications for the future. But through all this I kept on thinking that one day I should look at physics again. And finally in 2019, stimulated by a small technical breakthrough, as well as enthusiasm from physicists of a new generation, I decided it was time to try diving into physics again.
My practical tools had developed a lot since Iâd worked on A New Kind of Science. Andâas I have found so oftenâthe passage of years had given me greater clarity and perspective about what Iâd discovered in A New Kind of Science. And it turned out we were rather quickly able to make spectacular progress. A New Kind of Science had introduced definite ideas about how fundamental physics might work. Now we could see that these ideas were very much on the right track, but on their own they did not go far enough. Something else was needed.
In A New Kind of Science Iâd introduced what I called multiway systems, but Iâd treated them as a kind of sideshow. Nowâparticularly tipped off by quantum mechanicsâwe realized that multiway systems were not a sideshow but were actually in a sense the main event. They had come out of the computational paradigm of A New Kind of Science, but they were really harbingers of a new paradigm: the multicomputational paradigm.
In A New Kind of Science, Iâd already talked about spaceâand everything else in the universeâultimately being made up of a network of discrete elements that Iâd now call âatoms of spaceâ. And Iâd talked about time being associated with the inexorable progressive application of computationally irreducible rules. But now we were thinking not just of a single thread of computation, but instead of a whole multiway system of branching and merging threadsârepresenting in effect a multicomputational history for the universe.
In A New Kind of Science Iâd devoted a whole chapter to âProcesses of Perception and Analysisâ, recognizing the importance of the observer in computational systems. But with multicomputation there was yet more focus on this, and on how a physical observer knits things together to form a coherent thread of experience. Indeed, it became clear that itâs certain features of the observer that ultimately determine the laws of physics we perceive. And in particular it seems that as soon as weâsomehow reflecting core features of our conscious experienceâbelieve that we exist persistently through time, but are computationally bounded, then it follows that we will attribute to the universe the central known laws of spacetime and quantum mechanics.
At the level of atoms of space and individual threads of history everything is full of computational irreducibility. But the key point is that observers like us donât experience this; instead we sample certain computationally reducible featuresâthat we can describe in terms of meaningful âlaws of physicsâ.
I never expected it would be so easy, but by early 2020âonly a few months into our Wolfram Physics Projectâwe seemed to have successfully identified how the âmachine codeâ of our universe must work. A New Kind of Science had established that computation was a powerful way of thinking about things. But now it was becoming clear that actually our whole universe is in a sense âcomputational all the way downâ.
But where did this leave the traditional mathematical view? To my surprise, far from being at odds it seemed as if our computationallthewaydown model of physics perfectly plugged into a great many of the more abstract existing mathematical approaches. Mediated by multicomputation, the concepts of A New Kind of Scienceâwhich began as an effort to go beyond mathematicsâseemed now to be finding a kind of ultimate convergence with mathematics.
But despite our success in working out the structure of the âmachine codeâ for our universe, a major mystery remained. Letâs say we could find a particular rule that could generate everything in our universe. Then weâd have to ask âWhy this rule, and not another?â And if âour ruleâ was simple, how come weâd âlucked outâ like that? Ever since I was working on A New Kind of Science Iâd wondered about this.
And just as we were getting ready to announce the Physics Project in May 2020 the answer began to emerge. It came out of the multicomputational paradigm. And in a sense it was an ultimate version of it. Instead of imagining that the universe follows some particular ruleâalbeit applying it multicomputationally in all possible waysâwhat if the universe follows all possible rules?
And then we realized: this is something much more general than physics. And in a sense itâs the ultimate computational construct. Itâs what one gets if one takes all the programs in the computational universe that I studied in A New Kind of Science and runs them togetherâas a single, giant, multicomputational system. Itâs a single, unique object that I call the ruliad, formed as the entangled limit of all possible computations.
Thereâs no choice about the ruliad. Everything about it is abstractly necessaryâemerging as it does just from the formal concept of computation. A New Kind of Science developed the abstraction of thinking about things in terms of computation. The ruliad takes this to its ultimate limitâcapturing the whole entangled structure of all possible computationsâand defining an object that in some sense describes everything.
Once we believeâas the Principle of Computational Equivalence impliesâthat things like our universe are computational, it then inevitably follows that they are described by the ruliad. But the observer has a crucial role here. Because while as a matter of theoretical science we can discuss the whole ruliad, our experience of it inevitably has to be based on sampling it according to our actual capabilities of perception.
In the end, itâs deeply analogous to something thatâas I mention in A New Kind of Scienceâfirst got me interested in fundamental questions in science 50 years ago: the Second Law of thermodynamics. The molecules in a gas move around and interact according to certain rules. But as A New Kind of Science argues, one can think about this as a computational process, which can show computational irreducibility. If one didnât worry about the âmechanicsâ of the observer, one might imagine that one could readily âsee throughâ this computational irreducibility, to the detailed behavior of the molecules underneath. But the point is that a realistic, computationally bounded observerâlike usâwill be forced by computational irreducibility to perceive only certain âcoarsegrainedâ aspects of whatâs going on, and so will consider the gas to be behaving in a standard largescale thermodynamic way.
And so it is, at a grander level, with the ruliad. Observers like us can only perceive certain aspects of whatâs going on in the ruliad, and a key result of our Physics Project is that with only quite loose constraints on what weâre like as observers, itâs inevitable that we will perceive our universe to operate according to particular precise known laws of physics. And indeed the attributes that we associate with âconsciousnessâ seem closely tied to whatâs needed to get the features of spacetime and quantum mechanics that we know from physics. In A New Kind of Science one of the conclusions is that the Principle of Computational Equivalence implies a fundamental equivalence between systems (like us) that we consider âintelligentâ or âconsciousâ, and systems that we consider âmerely computationalâ.
But whatâs now become clear in the multicomputational paradigm is that thereâs more to this story. Itâs not (as people have often assumed) that thereâs something more powerful about âconscious observersâ like us. Actually, it’s rather the opposite: that in order to have consistent âconscious experienceâ we have to have certain limitations (in particular, computational boundedness, and a belief of persistence in time), and these limitations are what make us âsee the ruliadâ in the way that corresponds to our usual view of the physical world.
The concept of the ruliad is a powerful one, with implications that significantly transcend the traditional boundaries of science. For example, last year I realized that thinking in terms of the ruliad potentially provides a meaningful answer to the ultimate question of why our universe exists. The answer, I posit, is that the ruliadâas a âpurely formalâ objectâânecessarily existsâ. And what we perceive as âour universeâ is then just the âsliceâ that corresponds to what we can âseeâ from the particular place in ârulial spaceâ at which we happen to be. There has to be âsomething thereââand the remarkable fact is that for an observer with our general characteristics, that something has to have features that are like our usual laws of physics.
In A New Kind of Science I discussed how the Principle of Computational Equivalence implies that almost any system can be thought of as being âlike a mindâ (as in, âthe weather has a mind of its ownâ). But the issueâthat for example is of central importance in talking about extraterrestrial intelligenceâis how similar to us that mind is. And now with the ruliad we have a more definite way to discuss this. Different minds (even different human ones) can be thought of as being at different places in the ruliad, and thus in effect attributing different rules to the universe. The Principle of Computational Equivalence implies that there must ultimately be a way to translate (or, in effect, move) from one place to another. But the question is how far it is.
Our senses and measuring devicesâtogether with our general paradigms for thinking about thingsâdefine the basic area over which our understanding extends, and for which we can readily produce a highlevel narrative description of whatâs going on. And in the past we might have assumed that this was all weâd ever need to reach with whatever science we built. But what A New Kind of Scienceâand now the ruliadâshow us is that thereâs much more out there. Thereâs a whole computational universe of possible programsâmany of which behave in ways that are far from our current domain of highlevel understanding.
Traditional science we can view as operating by gradually expanding our domain of understanding. But in a sense the key methodological idea that launched A New Kind of Science is to do computational experiments, which in effect just âjump without prior understandingâ out into the wilds of the computational universe. And thatâs in the end why all that ruliology in A New Kind of Science at first looks so alien: weâve effectively jumped quite far from our familiar place in rulial space, so thereâs no reason to expect weâll recognize anything. And in effect, as the title of the book says, we need to be doing a new kind of science.
In A New Kind of Science, an important part of the story has to do with the phenomenon of computational irreducibility, and the way in which it prevents any computationally bounded observer (like us) from being able to âreduceâ the behavior of systems, and thereby perceive them as anything other than complex. But now that weâre thinking not just about computation, but about multicomputation, other attributes of other observers start to be important too. And with the ruliad ultimately representing everything, the question of what will be perceived in any particular case devolves into one about the characteristics of observers.
In A New Kind of Science I give examples of how the same kinds of simple programs (such as cellular automata) can provide good âmetamodelsâ for a variety of kinds of systems in nature and elsewhere, that show up in very different areas of science. But one feature of different areas of science is that theyâre often concerned with different kinds of questions. And with the focus on the characteristics of the observer this is something we get to captureâand we get to discuss, for example, what the chemical observer, or the economic observer, might be like, and how that affects their perception of whatâs ultimately in the ruliad.
In Chapter 12 of A New Kind of Science thereâs a long section on âImplications for Mathematics and Its Foundationsâ, which begins with the observation that just as many models in science seem to be able to start from simple rules, mathematics is traditionally specifically set up to start from simple axioms. I then analyzed how multiway systems could be thought of as defining possible derivations (or proofs) of new mathematical theorems from axioms or other theoremsâand I discussed how the difficulty of doing mathematics can be thought of as a reflection of computational irreducibility.
But informed by our Physics Project I realized that there’s much more to say about the foundations of mathematicsâand this has led to our recently launched Metamathematics Project. At the core of this project is the idea that mathematics, like physics, is ultimately just a sampling of the ruliad. And just as the ruliad defines the lowestlevel machine code of physics, so does it also for mathematics.
The traditional axiomatic level of mathematics (with its builtin notions of variables and operators and so on) is already higher level than the âraw ruliadâ. And a crucial observation is that just like physical observers operate at a level far above things like the atoms of space, so âmathematical observersâ mostly operate at a level far above the raw ruliad, or even the âassembly codeâ of axioms. In an analogy with gases, the ruliadâor even axiom systemsâare talking about the âmolecular dynamicsâ level; but âmathematical observersâ operate more at the âfluid dynamicsâ level.
And the result of this is what I call the physicalization of metamathematics: the realization that our âperceptionâ of mathematics is like our perception of physics. And that, for example, the very possibility of consistently doing higherlevel mathematics where we don’t always have to drop down to the level of axioms or the raw ruliad has the same origin as the fact that âobservers like usâ typically view space as something continuous, rather than something made up of lots of atoms of space.
In A New Kind of Science I considered it a mystery why phenomena like undecidability are not more common in typical pure mathematics. But now our Metamathematics Project provides an answer that’s based on the character of mathematical observers.
My stated goal at the beginning of A New Kind of Science was to go beyond the mathematical paradigm, and that’s exactly what was achieved. But now there’s almost a full circleâbecause we see that building on A New Kind of Science and the computational paradigm we reach the multicomputational paradigm and the ruliad, and then we realize that mathematics, like physics, is part of the ruliad. Or, put another way, mathematics, like physicsâand like everything elseâis âmade of computationâ, and all computation is in the ruliad.
And that means that insofar as we consider there to be physical reality, so also we must consider there to be âmathematical realityâ. Physical reality arises from the sampling of the ruliad by physical observers; so similarly mathematical reality must arise from the sampling of the ruliad by mathematical observers. Or, in other words, if we believe that the physical world exists, so we mustâessentially like Platoâalso believe that the mathematics exists, and that there is an underlying reality to mathematics.
All of these ideas rest on what was achieved in A New Kind of Science but now go significantly beyond it. In an âEpilogâ that I eventually cut from the final version of A New Kind of Science I speculated that âmajor new directionsâ might be built in 15â30 years. And when I wrote that, I wasn’t really expecting that I would be the one to be central in doing that. And indeed I suspect that had I simply continued the direct path in basic science defined by my work on A New Kind of Science, it wouldn’t have been me.
It’s not something I’ve explicitly planned, but at this point I can look back on my life so far and see it as a repeated alternation between technology and basic science. Each builds on the other, giving me both ideas and toolsâand creating in the end a taller and taller intellectual tower. But what’s crucial is that every alternation is in many ways a fresh start, where I’m able to use what I’ve done before, but have a chance to reexamine everything from a new perspective. And so it has been in the past few years with A New Kind of Science: having returned to basic science after 17 years away, it’s been possible to make remarkably rapid and dramatic progress that’s taken things to a new and wholly unexpected level.
In the course of intellectual history, thereâve been very few fundamentally different paradigms introduced for theoretical science. The first is what one might call the âstructural paradigmâ, in which oneâs basically just concerned with what things are made of. And beginning in antiquityâand continuing for two millenniaâthis was pretty much the only paradigm on offer. But in the 1600s there was, as I described it in the opening sentence of A New Kind of Science, a âdramatic new ideaââthat one could describe not just how things are, but also what they can do, in terms of mathematical equations.
And for three centuries this âmathematical paradigmâ defined the state of the art for theoretical science. But as I went on to explain in the opening paragraph of A New Kind of Science, my goal was to develop a new âcomputational paradigmâ that would describe things not in terms of mathematical equations but instead in terms of computational rules or programs. Thereâd been precursors to this in my own work in the 1980s, but despite the practical use of computers in applying the mathematical paradigm, there wasnât much of a concept of describing things, say in nature, in a fundamentally computational way.
One feature of a mathematical equation is that it aims to encapsulate âin one fell swoopâ the whole behavior of a system. Solve the equation and youâll know everything about what the system will do. But in the computational paradigm itâs a different story. The underlying computational rules for a system in principle determine what it will do. But to actually find out what it does, you have to run those rulesâwhich is often a computationally irreducible process.
Put another way: in the structural paradigm, one doesnât talk about time at all. In the mathematical paradigm, time is there, but itâs basically just a parameter, that if you can solve the equations you can set to whatever value you want. In the computational paradigm, however, time is something more fundamental: itâs associated with the actual irreducible progression of computation in a system.
Itâs an important distinction that cuts to the core of theoretical science. Heavily influenced by the mathematical paradigm, itâs often been assumed that science is fundamentally about being able to make predictions, or in a sense having a model that can âoutrunâ the system youâre studying, and say what itâs going to do with much less computational effort than the system itself.
But computational irreducibility implies that thereâs a fundamental limit to this. There are systems whose behavior is in effect âtoo complexâ for us to ever be able to âfind a formula for itâ. And this is not something we could, for example, resolve just by increasing our mathematical sophistication: it is a fundamental limit that arises from the whole structure of the computational paradigm. In effect, from deep inside science weâre learning that there are fundamental limitations on what science can achieve.
But as I mentioned in A New Kind of Science, computational irreducibility has an upside as well. If everything were computationally reducible, the passage of time wouldnât in any fundamental sense add up to anything; weâd always be able to âjump aheadâ and see what the outcome of anything would be without going through the steps, and weâd never have something we could reasonably experience as free will.
In practical computing itâs pretty common to want to go straight from âquestionâ to âanswerâ, and not be interested in âwhat happened insideâ. But in A New Kind of Science there is in a sense an immediate emphasis on âwhat happens insideâ. I donât just show the initial input and final output for a cellular automaton. I show its whole âspacetimeâ history. And now that we have a computational theory of fundamental physics we can see that all the richness of our physical experience is contained in the âprocess insideâ. We donât just want to know the endpoint of the universe; we want to live the ongoing computational process that corresponds to our experience of the passage of time.
But, OK, so in A New Kind of Science we reached what we might identify as the third major paradigm for theoretical science. But the excitingâand surprisingâthing is that inspired by our Physics Project we can now see a fourth paradigm: the multicomputational paradigm. And while the computational paradigm involves considering the progression of particular computations, the multicomputational paradigm involves considering the entangled progression of many computations. The computational paradigm involves a single thread of time. The multicomputational paradigm involves multiple threads of time that branch and merge.
What in a sense forced us into the multicomputational paradigm was thinking about quantum mechanics in our Physics Project, and realizing that multicomputation was inevitable in our models. But the idea of multicomputation is vastly more general, and in fact immediately applies to any system where at any given step multiple things can happen. In A New Kind of Science I studied many kinds of computational systemsâlike cellular automata and Turing machinesâwhere one definite thing happens at each step. I looked a little at multiway systemsâprimarily ones based on string rewriting. But now in general in the multicomputational paradigm one is interested in studying multiway systems of all kinds. They can be based on simple iterations, say involving numbers, in which multiple functions can be applied at each step. They can be based on systems like games where there are multiple moves at each step. And they can be based on a whole range of systems in nature, technology and elsewhere where there are multiple âasynchronousâ choices of events that can occur.
Given the basic description of multicomputational systems, one might at first assume that whatever difficulties there are in deducing the behavior of computational systems, they would only be greater for multicomputational systems. But the crucial point is that whereas with a purely computational system (like a cellular automaton) itâs perfectly reasonable to imagine âexperiencingâ its whole evolutionâsay just by seeing a picture of it, the same is not true of a multicomputational system. Because for observers like us, who fundamentally experience time in a single thread, we have no choice but to somehow âsampleâ or âcoarse grainâ a multicomputational system if we are to reduce its behavior to something we can âexperienceâ.
And thereâs then a remarkable formal fact: if one has a system that shows fundamental computational irreducibility, then computationally bounded âsinglethreadoftimeâ observers inevitably perceive certain effective behavior in the system, that follows something like the typical laws of physics. Once again we can make an analogy with gases made from large numbers of molecules. Largescale (computationally bounded) observers will essentially inevitably perceive gases to follow, say, the standard gas laws, quite independent of the detailed properties of individual molecules.
In other words, the interplay between an âobserver like usâ and a multicomputational system will effectively select out a slice of computational reducibility from the underlying computational irreducibility. And although I didnât see this coming, itâs in the end fairly obvious that something like this has to happen. The Principle of Computational Equivalence makes it basically inevitable that the underlying processes in the universe will be computationally irreducible. But somehow the particular features of the universe that we perceive and care about have to be ones that have enough computational reducibility that we can, for example, make consistent decisions about what to do, and weâre not just continually confronted by irreducible unpredictability.
So how general can we expect this picture of multicomputation to be, with its connection to the kinds of things weâve seen in physics? It seems to be extremely general, and to provide a true fourth paradigm for theoretical science.
There are many kinds of systems for which the multicomputational paradigm seems to be immediately relevant. Beyond physics and metamathematics, there seems to be nearterm promise in chemistry, molecular biology, evolutionary biology, neuroscience, immunology, linguistics, economics, machine learning, distributed computing and more. In each case there are underlying lowlevel elements (such as molecules) that interact through some kind of events (say collisions or reactions). And then thereâs a big question of what the relevant observer is like.
In chemistry, for example, the observer could just measure the overall concentration of some kind of molecule, coarsegraining together all the individual instances of those molecules. Or the observer could be sensitive, for example, to detailed causal relationships between collisions among molecules. In traditional chemistry, things like this generally arenât âobservedâ. But in biology (for example in connection with membranes), or in molecular computing, they may be crucial.
When I began the project that became A New Kind of Science the central question I wanted to answer is why we see so much complexity in so many kinds of systems. And with the computational paradigm and the ubiquity of computational irreducibility we had an answer, which also in a sense told us why it was difficult to make certain kinds of progress in a whole range of areas.
But now weâve got a new paradigm, the multicomputational paradigm. And the big surprise is that through the intermediation of the observer we can tap into computational reducibility, and potentially find âphysicslikeâ laws for all sorts of fields. This may not work for the questions that have traditionally been asked in these fields. But the point is that with the âright kind of observerâ thereâs computational reducibility to be found. And that computational reducibility may be something we can tap into for understanding, or to use some kind of system for technology.
It can all be seen as starting with the ruliad, and involving almost philosophical questions of what one can call âobserver theoryâ. But in the end it gives us very practical ideas and methods that I think have the potential to lead to unexpectedly dramatic progress in a remarkable range of fields.
I knew that A New Kind of Science would have practical applications, particularly in modeling, in technology and in producing creative material. And indeed it has. But for our Physics Project applications seemed much further away, perhaps centuries. But a great surprise has been that through the multicomputational paradigm it seems as if there are going to be some quite immediate and very practical applications of the Physics Project.
In a sense the reason for this is that through the intermediation of multicomputation we see that many kinds of systems share the same underlying âmetastructureâ. And this means that as soon as there are things to say about one kind of system these can be applied to other systems. And in particular the great successes of physics can be applied to a whole range of systems that share the same multicomputational metastructure.
An immediate example is in practical computing, and particularly in the Wolfram Language. Itâs something of a personal irony that the Wolfram Language is based on transformation rules for symbolic expressions, which is a structure very similar to what ends up being whatâs involved in the Physics Project. But thereâs a crucial difference: in the usual case of the Wolfram Language, everything works in a purely computational way, with a particular transformation being done at each step. But now thereâs the potential to generalize that to the multicomputational case, and in effect to trace the multiway system of every possible transformation.
Itâs not easy to pick out of that structure things that we can readily understand. But there are important lessons from physics for this. And as we build out the multicomputational capabilities of the Wolfram Language I fully expect that the ânotational clarityâ it will bring will help us to formulate much more in terms of the multicomputational paradigm.
I built the Wolfram Language as a tool that would help me explore the computational paradigm, and from that paradigm there emerged principles like the Principle of Computational Equivalence, which in turn led me to see the possibility of something like WolframAlpha. But now from the latest basic science built on the foundations of A New Kind of Science, together with the practical tooling of the Wolfram Language, itâs becoming possible again to see how to make conceptual advances that can drive technology that will again in turn let us makeâlikely dramaticâprogress in basic science.
A New Kind of Science is full of intellectual seeds. And in the past few yearsâhaving now returned to basic scienceâIâve been harvesting a few of those seeds. The Physics Project and the Metamathematics Project are two major results. But thereâs been quite a bit more. And in fact itâs rather remarkable how many things that were barely more than footnotes in A New Kind of Science have turned into major projects, with important results.
Back in 2018âa year before beginning the Physics ProjectâI returned, for example, to whatâs become known as the Wolfram Axiom: the axiom that I found in A New Kind of Science that is the very simplest possible axiom for Boolean algebra. But my focus now was not so much on the axiom itself as on the automated process of proving its correctness, and the effort to see the relation between âpure computationâ and what one might consider a humanabsorbable ânarrative proofâ.
Computational irreducibility appeared many times, notably in my efforts to understand AI ethics and the implications of computational contracts. Iâve no doubt that in the years to come, the concept of computational irreducibility will become increasingly important in everyday thinkingâa bit like how concepts such as energy and momentum from the mathematical paradigm have become important. And in 2019, for example, computational irreducibility made an appearance in government affairs, as a result of me testifying about its implications for legislation about AI selection of content on the internet.
In A New Kind of Science I explored many specific systems about which one can ask all sorts of questions. And one might think that after 20 years âall the obvious questionsâ would have been answered. But they have not. And in a sense the fact that they have not is a direct reflection of the ubiquity of computational irreducibility. But itâs a fundamental feature that whenever thereâs computational irreducibility, there must also be pockets of computational reducibility: in other words, the very existence of computational irreducibility implies an infinite frontier of potential progress.
Back in 2007, weâd had great success with our Turing Machine Prize, and the Turing machine that Iâd suspected was the very simplest possible universal Turing machine was indeed proved universalâproviding another piece of evidence for the Principle of Computational Equivalence. And in a sense thereâs a general question thatâs raised by A New Kind of Science about where the threshold of universalityâor computational equivalenceâreally is in different kinds of systems.
But there are simplertodefine questions as well. And ever since I first studied rule 30 in 1984 Iâd wondered about many questions related to it. And in October 2019 I decided to launch the Rule 30 Prizes, defining three specific easytostate questions about rule 30. So far I donât know of progress on them. And for all I know theyâll be open problems for centuries. From the point of view of the ruliad we can think of them as distant explorations in rulial space, and the question of when they can be answered is like the question of when weâll have the technology to get to some distant place in physical space.
Having launched the Physics Project in April 2020, it was rapidly clear that its ideas could also be applied to metamathematics. And it even seemed as if it might be easier to make relevant ârealworldâ observations in metamathematics than in physics. And the seed for this was in a note in A New Kind of Science entitled âEmpirical Metamathematicsâ. That note contained one picture of the theoremdependency graph of Euclidâs Elements, which in the summer of 2020 expanded into a 70page study. And in my recent âPhysicalization of Metamathematicsâ thereâs a continuation of thatâbeginning to map out empirical metamathematical space, as explored in the practice of mathematics, with the idea that multicomputational phenomena that in physics may take technically infeasible particle accelerators or telescopes might actually be within reach.
In addition to being the year we launched our Physics Project, 2020 was also the 100th anniversary of combinatorsâthe first concrete formalization of universal computation. In A New Kind of Science I devoted a few pages and some notes to combinators, but I decided to do a deep dive and use both what Iâd learned from A New Kind of Science and from the Physics Project to take a new look at them. Among other things the result was another application of multicomputation, as well as the realization that even though the S, K combinators from 1920 seemed very minimal, it was possible that S alone might also be universal, though with something different than the usual input → output âworkflowâ of computation.
In A New Kind of Science a single footnote mentions multiway Turing machines. And early last year I turned this seed into a long and detailed study that provides further foundational examples of multicomputation, and explores the question of just what it means to âdo a computationâ multicomputationallyâsomething which I believe is highly relevant not only for practical distributed computing but also for things like molecular computing.
In 2021 it was the centenary of Post tag systems, and again I turned a few pages in A New Kind of Science into a long and detailed study. And whatâs important about both this and my study of combinators is that they provide foundational examples (much like cellular automata in A New Kind of Science), which even in the past year or so Iâve used multiple times in different projects.
In mid2021, yet another fewpage discussion in A New Kind of Science turned into a detailed study of âThe Problem of Distributed Consensusâ. And once again, this turned out to have a multicomputational angle, at first in understanding the multiway character of possible outcomes, but later with the realization that the formation of consensus is deeply related to the process of measurement and the coarsegraining involved in itâand the fundamental way that observers extract âcoherent experiencesâ from systems.
In A New Kind of Science, thereâs a short note about multiway systems based on numbers. And once again, in fall 2021 I expanded on this to produce an extensive study of such systems, as a certain kind of very minimal example of multicomputation, that at least in some cases connects with traditional mathematical ideas.
From the vantage point of multicomputation and our Physics Project itâs interesting to look back at A New Kind of Science, and see some of what it describes with more clarity. In the fall of 2021, for example, I reviewed what had become of the original goal of “understanding complexity”, and what methodological ideas had emerged from that effort. I identified two primary ones, which I called âruliologyâ and âmetamodelingâ. Ruliology, as Iâve mentioned above, is my new name for the pure, basic science of studying the behavior of systems with simple rules: in effect, itâs the science of exploring the computational universe.
Metamodeling is the key to making connections to systems in nature and elsewhere that one wants to study. Its goal is to find the âminimal models for modelsâ. Often there are existing models for systems. But the question is what the ultimate essence of those models is. Can everything be reduced to a cellular automaton? Or a multiway system? What is the minimal “computational essence” of a system? And as we begin to apply the multicomputational paradigm to different fields, a key step will be metamodeling.
Ruliology and metamodeling are in a sense already core concepts in A New Kind of Science, though not under those names. Observer theory is much less explicitly covered. And many conceptsâlike branchial space, tokenevent graphs, the multiway causal graph and the ruliadâhave only emerged now, with the Physics Project and the arrival of the multicomputational paradigm.
Multicomputation, the Physics Project and the Metamathematics Project are sowing their own seeds. But there are still many more seeds to harvest even from A New Kind of Science. And just as the multicomputational paradigm was not something that I, for one, could foresee from A New Kind of Science, no doubt there will in time be other major new directions that will emerge. But, needless to say, one should expect that it will be computationally irreducible to determine what will happen: a metacontribution of the science to the consideration of its own future.
The creation of A New Kind of Science took me a decade of intense work, none of which saw the light of day until the moment the book was published on May 14, 2002. Returning to basic science 17 years later the world had changed and it was possible for me to adopt a quite different approach, in a sense making the process of doing science as open and incremental as possible.
Itâs helped that thereâs the web, the cloud and livestreaming. But in a sense the most crucial element has been the Wolfram Language, and its character as a fullscale computational language. Yes, I use English to tell the story of what weâre doing. But fundamentally Iâm doing science in the Wolfram Language, using it both as a practical tool, and as a medium for organizing my thoughts, and sharing and communicating what Iâm doing.
Starting in 2003, weâve had an annual Wolfram Summer School at which a long string of talented students have explored ideas based on A New Kind of Science, always through the medium of the Wolfram Language. In the last couple of years weâve added a Physics track, connected to the Physics Project, and this year weâre adding a Metamathematics track, connected to the Metamathematics Project.
During the 17 years that I wasnât focused on basic science, I was doing technology development. And I think itâs fair to say that at Wolfram Research over the past 35 years weâve created a remarkably effective âmachineâ for doing innovative research and development. Mostly itâs been producing technology and products. But one of the very interesting features of the Physics Project and the projects that have followed it is that weâve been applying the same managed approach to innovation to them that we have been using so successfully for so many years at our company. And I consider the results to be quite spectacular: in a matter of weeks or months I think weâve managed to deliver what might otherwise have taken years, if it could have been done at all.
And particularly with the arrival of the multicomputational paradigm thereâs quite a challenge. There are a huge number of exceptionally promising directions to follow, that have the potential to deliver revolutionary results. And with our concepts of managed research, open science and broad connection to talent it should be possible to make great progress even fairly quickly. But to do so requires significant scaling up of our efforts so far, which is why weâre now launching the Wolfram Institute to serve as a focal point for these efforts.
When I think about A New Kind of Science, I canât help but be struck by all the things that had to align to make it possible. My early experiences in science and technology, the personal environment Iâd createdâand the tools I built. I wondered at the time whether the five years I took âaway from basic scienceâ to launch Mathematica and whatâs now the Wolfram Language might have slowed down what became A New Kind of Science. Looking back I can say that the answer was definitively no. Because without the Wolfram Language the creation of A New Kind of Science would have needed ânot just a decadeâ, but likely more than a lifetime.
And a similar pattern has repeated now, though even more so. The Physics Project and everything that has developed from it has been made possible by a tower of specific circumstances that stretch back nearly half a centuryâincluding my 17year hiatus from basic science. Had all these circumstances not aligned, it is hard to say when something like the Physics Project would have happened, but my guess is that it would have been at least a significant part of a century away.
It is a lesson of the history of science that the absorption of major new paradigms is a slow process. And normally the timescales are long compared to the 20 years since A New Kind of Science was published. But in a sense weâve managed to jump far ahead of schedule with the Physics Project and with the development of the multicomputational paradigm. Five years ago, when I summarized the first 15 years of A New Kind of Science I had no idea that any of this would happen.
But now that it hasâand with all the methodology weâve developed for getting science doneâit feels as if we have a certain obligation to see just what can be achieved. And to see just what can be built in the years to come on the foundations laid down by A New Kind of Science.
]]>In the end itâs about five and a half pounds of paper, 1280 pages, 973 illustrations and 583,313 words. And its creation took more than a decade of my life. Almost every day of my thirties, and a little beyond, I tenaciously worked on it. Figuring out more and more science. Developing new kinds of computational diagrams. Crafting an exposition that I wrote and rewrote to make as clear as possible. And painstakingly laying out page after page of what on May 14, 2002, would be published as A New Kind of Science.
Iâve written before (even in the book itself) about the intellectual journey involved in the creation of A New Kind of Science. But here I want to share some of the more practical âbehind the scenesâ journey of the making of what I and others usually now call simply âthe NKS bookâ. Some of what Iâll talk about happened twenty years ago, some more like thirty years ago. And itâs been interesting to go back into my archives (and, yes, those backup tapes from 30 years ago were hard to read!) and relive some of what finally led to the delivery of the ideas and results of A New Kind of Science as truckloads of elegantly printed books with striking covers.
It was late 1989âsoon after my 30th birthdayâwhen I decided to embark on what would become A New Kind of Science. And at first my objective was quite modest: I just wanted to write a book to summarize the science Iâd developed earlier in the 1980s. We’d released Version 1.0 of Mathematica (and whatâs now the Wolfram Language) in June 1988, and to accompany that release Iâd written what had rapidly become a very successful book. And while Iâd basically built Mathematica to give me the opportunity to do more science, my thought in late 1989 was that before seriously embarking on that, I should spend perhaps a year and write a book about what I already knew, and perhaps tie up a few loose ends in the process.
My journey in science began in the early 1970sâand by the time I was 14 Iâd already written three booklength “treatises” about physics (though these wouldnât see the light of day for several more decades). I worked purely on physics for a number of years, but in 1979 this led me into my first big adventure in technologyâthereby starting my (very productive) longterm personal pattern of alternating between science and technology (roughly five times so far). In the early 1980sâback in a âscience phaseââI was fortunate enough to make what remains my alltime favorite science discovery: that in cellular automaton programs even with extremely simple rules itâs possible to generate immense complexity. And from this discovery I was led to a series of results that began to suggest what I started calling a general “science of complexity”.
By the mid1980s I was quite well positioned in the academic world, and my first thought was to try to build up the study of the âscience of complexityâ as an academic field. I started a journal and a research center, and collected my papers in a book entitled Theory and Applications of Cellular Automata (later reissued as Cellular Automata and Complexity). But things developed slowly, and eventually I decided to go to âplan Bââand just try to create the tools and environment that I would need to personally push forward the science as efficiently as possible.
The result was that in late 1986 I started the development of Mathematica (and whatâs now the Wolfram Language) and founded Wolfram Research. For several years I was completely consumed with the challenges of language design, software development and CEOing our rapidly growing company. But in August 1989 we had released Mathematica 1.2 (tying up the most obvious loose ends of Version 1.0)âand with the intensity of my other commitments at least temporarily reduced, I began to think about science again.
The Mathematica Book had been comparatively straightforward and fast for me to writeâeven as a âside projectâ to architecting and developing the system. And I imagined that it would be a somewhat similar experience writing a book explaining what Iâd figured out about complexity.
My first working title was Complexity: An Introduction to the Science of Complex Phenomena. My first draft of a table of contents, from November 1989, begins with âA Gallery of Complex Systemsâ (or âThe Phenomenon of Complexityâ), and continues through nine other chapters, capturing some of what I then thought would be important (and in most cases had already studied):
I wrote a few pages of introductory textâbeginning by stating the objective as:
My archives record that in late December I was taking a more computationfirst approach, and considering the title Algorithms in Nature: An Introduction to Complexity. But soon I was submerged in the intense effort to develop Mathematica 2.0, and this is what consumed me for most of 1990âthough my archives from the time reveal one solitary short note, apparently from the middle of the year:
But through all this I kept thinking about the book I intended to write, and wondering what it should really be like. In the late 1980s thereâd been quite a run of unexpectedly successful âpopular scienceâ booksâlike A Brief History of Timeâthat mixed what were at least often claimed to be new results or new insights about science with a kind of intendedtoentertain âeveryman narrativeâ. A sequence of publishers had encouraged me to âwrite a popular science bookâ. But should the book I was planning to write really be one of those?
I talked to quite a few authors and editors. But nobody could quite tell a coherent story. Perhaps the most promising insight came from an editor of several successful such books, who opined that he thought the main market for âpopular scienceâ books was people who in the past would have read philosophy books, but now those were too narrow and technical. Other people, though, told me they thought it was really more of an âinternal marketâ, with the books basically being bought by other scientists. And in the media and elsewhere there continued to be an undercurrent of sentiment that while the books might be being bought, they mostly werenât actually getting read.
âIsnât there actual data on whatâs going on?â I asked my publishing industry contacts. âNoâ, they said, âthatâs just not how our industry worksâ. âWellâ, I said, âwhy donât we collect some data?â My thenpublisher seemed enthusiastic about it. So I wrote a rather extensive survey to do on ârandom shoppersâ in bookstores. It began with some basicâif â1990styleââdemographic questions, then got to things like
and rather charmingly ended with
(and, yes, in reality it took almost the longest time I could imagine for electronic books to become common). But after many months of âweâll get results soonâ it turned out almost no surveys were ever done. As I would learn repeatedly, most publishers seemed to have a very hard time doing anything they hadnât already done before. Still, my thenpublisher had done well with The Mathematica Book. So perhaps they might be able to just âfollow a formulaâ and do well with my book if it was written in âpopular scienceâ form.
But I quickly realized that the pressure to add sensationalism âto sell booksâ really grated on me. And it didnât take long to decide that, no, I wasnât going to write a âformulaâ popular science book. I was going to write my own kind of bookâthat was more direct and straightforward. No stories. Just science. With lots of pictures. And if nothing else, the book would at least be helpful to me, as a way of clarifying my own thinking.
In January 1991 we announced Mathematica 2.0âand in March and June I did a 35city tour of the US and Europe talking about it. Then, finally, at the beginning of July we delivered final floppy disks to the duplicator (as one did in those days)âand Mathematica 2.0 was on its way. So what next? I had a long roadmap of things we should do. But I decided it was time to let the team Iâd built just get on with following the roadmap for a while, without me adding yet more things to it. (As it turns out, we finally finished essentially everything that was on my 1991 todo list just a few years ago.)
And so it was that in July 1991 I became a remote CEO (yes, a few decades ahead of the times), moved a couple thousand miles away from our company headquarters to a place in the hills near San Francisco, and set about getting ready to write. Based on the plan I had for the bookâand my experience with The Mathematica BookâI figured it might take about a year, or maybe 18 months, to finish the project.
In the endâwith a few trips in the middle, notably to see a total solar eclipseâit took me a couple of months to get my remoteCEO setup figured out (with a swank computerconnected fax machine, email getting autodelivered every 15 minutes, etc.). But even while that was going on, I was tooling up to get an efficient modern system for visualizing and studying cellular automata. Back when I had been writing my papers in the 1980s, Iâd had a C program (primarily for Sun workstations) that had gradually grown, and was eventually controlled by a rather elaborateâbut sensibleforitstimeâhierarchical textual menu system
which, yes, could generate at least singlegraphicperscreen graphics, as in this picture of my 1983 office setup:
But now the world had changed, and I had Mathematica. And I wanted a nice collection of Wolfram Language functions that could be used as streamlined âprimitivesâ for studying cellular automata. Given all my work on cellular automata it might seem strange that I hadnât built cellular automaton functionality into the Wolfram Language right from the start. But in addition to being a bit bashful about my personal pet kind of system, I hadnât been able to see how to âpackageâ all the various different kinds of cellular automata Iâd studied into one convenient superfunctionâand indeed it took me a decade more of understanding, both of language design and of cellular automata, to work out how to nicely do that. And so back in 1991 I just created a collection of addon functions (or what might today be a paclet) containing the particular functions I needed. And indeed those functions served me well over the course of the development of A New Kind of Science.
A âstagedâ screen capture from the time shows my basic working environment:
Some printouts from early 1991 give a sense of my everyday experience:
And although it’s now more than 30 years later, I’m happy to say that we’ve successfully maintained the compatibility of the Wolfram Language, and those same functions still just run! The .ma format of my Version 2.0 notebooks from 1991 has to be converted to .nb, but then they just open in Version 13 (with a bit of automatic style modernization) and Iâm immediately âtransported back in timeâ to 1991, with, yes, a very small notebook appropriate for a 1991 rather than a 2022 screen size:
(Of course the cellular automata all look the same, but, yes, this notebook looks shockingly similar to ones from our recent cellular automaton NFTminting event.)
Weâd invented notebooks in 1987 to be able to do just the kinds of things I wanted to do for my science projectâand Iâd been itching to use them. But before 1991 Iâd mostly been doing core code development (often in C), or using the elaborate but still textual system we had for authoring The Mathematica Book. And soâeven though Iâd demoed them many timesâI hadnât had a chance to personally make daily use of notebooks.
But in 1991, I went all in on notebooksâand have never looked back. When I first started studying cellular automata back in 1981, Iâd had to display their output as text. But soon I was able to start using the bitmapped displays of workstation computers, and by 1984 I was routinely printing cellular automaton images in fairly high resolution on a laser printer. But with Mathematica and our notebook technology things got dramatically more convenientâand what had previously often involved laborious work with paper, scissors and tape now became a matter of simple Wolfram Language code in a notebook.
For almost a decade starting in 1982, my primary computer had been a progressively more sophisticated Sun workstation. But in 1991 I switched to NeXTâmainly to be able to use our notebook interface, which was by then well developed for NeXT but wasnât yet ready on X Windows and Sun. (It was also available on Macintosh computers, but at the time those werenât powerful enough.)
And here I am in 1991, captured âhiding outâ as a remote CEO, with a NeXT in the background, just getting started on the book:
Hereâs a picture showing a bit more of the setup, taken in early 1993, during a short period when I was a remoteremoteCEO, with my computer set up in a hotel room:
Throughout the 1980s, Iâd used cellular automataâand basically cellular automata aloneâas my window into the computational universe. But in August 1991âwith my new computational capabilities and new awayfromthecompanytodoscience setupâI decided itâd be worth trying to look at some other systems.
And I have to say that now, three decades later, I didnât remember just how suddenly everything happened. But my filesystem records that in successive days at the beginning of September 1991 there I was investigating more and more kinds of systems (.maâs were âMathematica notebookâ files; .mbâs were the âbinary forksâ of these files):
Mobile automata. Turing machines. Tag systems. Soon these would be joined by register machines, and more. The first examples of these systems tended to have quite simple behavior. But I quickly started searching to see whether these systemsâlike cellular automataâwould be capable of complex behavior, as my 1991 notebooks record:
Often I would run programs overnight, or sometimes for many days. Later I would recruit many computers from around our company, and have them send me mail about their results:
But already in September 1991 I was starting to see that, yes, just like cellular automata, all these different kinds of systems, even when their underlying rules were simple, could exhibit highly complex behavior. I think Iâd sort of implicitly assumed this would be true. But somehow actually seeing it began to elevate my view of just how general a âscience of complexityâ one might be able to make.
There were a few distractions in the fall of 1991. Like in October a large fire came within about half a mile of burning down our house:
But by the spring of 1992 it was beginning to become clear that there was a very general principle around all this complexity I was seeing. I had invented the concept of computational irreducibility back in 1984. And I suppose in retrospect I should have seen the bigger picture sooner. But as it was, on a pleasant afternoon (and, no, I havenât figured out the exact date), I was taking a short break from being in front of my computer, and had wandered outside. And thatâs when the Principle of Computational Equivalence came to me. Somehow after all those years with cellular automata, and all those months with computer experiments on other systems, I was primed for it. But in the end it all arrived in one moment: the concept, the name, the implications for computational irreducibility. And in the three decades since, itâs been the single most important guiding principle for my intuition.
Iâve always found it difficult to produce âdisembodied contentâ: right from the beginning I typically need to have a pretty clear idea how what Iâm producing will look in the end. So back in 1991 I really couldnât produce more than a page or two of content for my book without knowing what the book was going to look like.
âFormulaâ popular science books tendedâfor what I later realized were largely economic reasonsâto consist mainly of pages of pure text, with at most line drawings, and to concentrate whatever things like photographs they might have into a special collection of âplatesâ in the middle of the book. For The Mathematica Book weâd developed a definiteâvery functionalâlayout, with text, tables and twocolumn âcomputer dialogsâ:
For the NKS book I knew I needed something much more visual. And at first I imagined it might be a bit like a highend textbook, complete with all sorts of structured elements (âHistorical Noteâ, âMethodologyâ, etc.).
I asked a talented young designer who had worked on The Mathematica Book (and who, 31 years later, is now a very senior executive at our company) to see what he could come up with. And here, from November 1991, is the very first âlookâ for the NKS bookâwith content pretty much just flowed in from the few pages Iâd written out in plain text:
I knew the book would have images of the kind Iâd long produced of cellular automata, and that had appeared in my papers and book from the 1980s:
But what about âdiagramsâ? At first we toyed with drawing âtextbookstyleâ diagramsâand produced some samples:
But these seemed to have way too much “conceptual baggage”, and when one looks closely at them, it’s easy to get confused. I wanted something more minimalâwhere the spotlight was as much as possible on the systems I was studying, not on “diagrammatic scaffolding”. And so I tried to develop a “direct diagramming” methodology, where each diagram could directly “explain itself”âand where every diagram would be readable “purely visually”, without words.
In a typical case I might show the behavior of a system (here a mobile automaton), next to an explicit âvisual templateâ of how its rules operate. The idea then was that even a reader who didnât understand the bigger story, or any of the technical details, could still âmatch up templatesâ and understand what was going on in a particular picture:
At the beginning of the project, the diagrams were comparatively simple. But as the project progressed I invented more and more mechanisms for them, until later in the project I was producing very complex “visually readable” diagrams like this:
A crucial point was that all these diagrams were being produced algorithmicallyâwith Wolfram Language code. And in fact I was developing the diagrams as an integral part of actually doing the research for the book. It was a lesson Iâd learned years earlier: donât wait until research is âfinishedâ to figure out how to present it; work out the presentation as early as possible, so you can use it to help you actually do the research.
Another aspect of our first âtextbooklikeâ style for the book was the idea of having additional elements, alongside the âmain narrativeâ of the book. In early layouts we thought about having âTechnical Notesâ, âHistorical Notesâ, âImplementation Notesâ, etc. But it didnât take too long to decide that no, that was just going to be too complicated. So we made the decision to have one kind of note, and to collect all notes at the back of the book.
And that meant that in the main part of the book we had just two basic elements: text and images (with captions). But, OK, in designing any book a very basic question is: what size and shape will its pages be? The Mathematica Book was squarishâlike a typical textbookâso that it accommodated its textontheleft codeontheright âdialogsâ. We knew that the new book should be wide too, to accommodate the kinds of graphics I expected. But that posed a problem.
In The Mathematica Book ordinary text ran the full width of the page. And that worked OK, because in that book the text was typically broken up by dialogs, tables, etc. In the new book, however, I expected much longer blocks of pure textâwhich wouldnât be readable if they ran the full width of the page. But if the text was narrower, then how would the graphics not look like they were awkwardly sticking out? Well, the pages would have to be carefully laid out to appropriately anchor the graphics visually, say to the tops or bottoms of pages. And that was going to make the process of layout much trickier.
Different pages were definitely going to look different. But there had to be a certain overall consistency. Every graphic was going to have a captionâand actually a caption that was sufficiently selfcontained so that people could basically âread the book just by looking at the picturesâ. Within the graphics themselves there had to be standards. How should arrays of cells be rendered? To what extent should things have boxes around them, or arrows between them? How big should pictures that emphasized particular features be?
Some of these standards got implemented basically just by me remembering to follow them. But others were essentially the result of the whole stack of Wolfram Language functions that we built to produce the algorithmic diagrams for the book. At the time, there was some fiddliness to these functions, and to making their output look goodâthough in later years what we learned from this was used to tune up the general look of builtin graphics in the Wolfram Language.
One of the striking features of the NKS book is the crispness of its pictures. And I think itâs fair to say that this wasnât easy to achieveâand in the end required a pretty deep dive into the technology of imaging and printing (as Iâll describe more in a later section).
Back in the 1980s Iâd had plenty of pictures of things like cellular automata in my papers. And Iâd produced them by outputting what amounted to pages of bitmaps on laser printers, then having publishers photographically reproduce the pictures for printing.
Up to a point the results were OK:
But for example in 1985 when I wanted a 2000step picture of rule 30 things got difficult. The computation (which, yes, involves 8 million cells) was done on a prototype Connection Machine parallel computer. And at first the output was generated on a largeformat printer that was usually used to print integrated circuit layouts. The result was quite large, and I subsequently laminated pictures like this (and in rolledup form they served as engaging hiding places for my children when they were very young):
But when photographically reproduced and printed in a journal the picture definitely wasnât great:
And the NKS book provided another challenge as well. While the core of a picture might just be an array of cells like in a cellular automaton, a full algorithmic diagram could contain all sorts of other elements.
In the end, the NKS book was a beneficiary of an important design decision that we made back in 1987, early in the development of Mathematica. At the time, most graphics were thought about in terms of bitmaps. On whatever device one was using, there was an array of pixels of a certain resolution. And the focus was on rendering the graphics at that resolution. Not everything worked that way, though. And âdrawingâ (as opposed to âpaintingâ) programs typically created graphics in âvectorâ form, in which at first primitives like lines and polygons were specified without reference to resolution, and were then converted to bitmaps only when they were displayed.
The shapes of characters in fonts were something that was often specifiedâat least at an underlying levelâin vector form. Thereâd been various approaches to doing this, but by 1987 PostScript was an emerging standardâat least for printingâbuoyed by its use in the Apple LaserWriter. The main focus of PostScript was on fonts and text, but the PostScript language also included standard graphics primitives like lines and polygons.
Back when I had built SMP in 1979â1981 weâd basically had to build a separate driver for every different display or printing device we wanted to output graphics on. But in 1987 there was an alternative: just use PostScript for everything. Printer manufacturers were working hard to support PostScript on their printers, but PostScript mostly hadnât come to screens yet. There was an important exception though: the NeXT computer was set up to have PostScript as its native screenrendering system. And partly through that, we decided to use PostScript as our underlying way to represent all graphics in Mathematica.
At a high level, graphics were described with the same symbolic primitives as we use in the Wolfram Language today: Line, Polygon, etc. But these were converted internally to PostScriptâand even stored in notebooks that way. On the NeXT this was pretty much the end of the story, but on other systems we had to write our own interpreters for at least the subset of PostScript we were using.
Why was this important to the NKS book? Well, it meant that all graphics could be specified in a fundamentally resolutionindependent way. In developing the graphics I could look at them in a notebook on a screen, or I could print them on a standard laser printer. But for the final book the exact same graphics could be printed at much higher resolutionâand look much crisper.
At the time, the standard resolution of a computer screen was 72 dpi (dots per inch) and the resolution of a typical laser printer was 300 dpi. But the typical basic resolution of a bookprinting pipeline was more like 2400 dpi. Iâll talk later about the adventure of actually printing the NKS book. But the key point was that because Mathematicaâs graphics were fundamentally based on PostScript, they werenât tied to any particular resolution, so they could in principle make use of whatever resolution was available.
Needless to say, there were plenty of complicated issues. One had to do with indicating the cells in something like a cellular automaton. Hereâs a picture of the first few steps of rule 30, shown as a kind of âmacro bitmapâ, with pure black and white cells:
✕

But often I wanted to indicate the extent of each cell:
✕

And in late 1991 and early 1992 we worried a lot about how to draw the âmeshâ between cells. A first thought was just to use a thin black line. But that obviously wouldnât work, because it wouldnât separate black cells. And we soon settled on a GrayLevel[.15] line, which was visible against both black and white.
But how is such a line printed? If weâre just using black ink, thereâs ultimately either black or white at a particular place on the page. But thereâs a standard way to achieve the appearance of gray, by changing the local density of black and white. And the typical method used to implement this is (as weâll discuss later) halftoning, in which one renders the âgrayâ by using black dots of different sizes.
But by the time one’s using very thin gray lines, things are getting very tricky. For example, it matters how much the ink on either side of the line spreadsâbecause if it’s too much it can effectively fill in where the line was supposed to be. We wanted to define standards that we could use throughout the NKS book. And we couldn’t tell what would happen in the final printed book except by actually trying it, on a real printing press. So already in early 1992 we started doing print tests, trying out different thicknesses of lines and so on. And that allowed us to start setting graphics standards that we could implement in the Wolfram Language code used to make the algorithmic diagrams, that would then flow through to all renderings of those diagrams.
Back in 1991 we debated quite a bit whether the NKS book should use color. We knew it would be significantly more expensive to print the book in color. But would color allow seriously better communication of information? Twocolor cellular automata like rule 30 can be rendered in pure black and white. But over the years Iâd certainly made many striking color pictures of cellular automata with more colors.
Somehow, though, those pictures hadnât seemed quite as crisp as the black and white ones. And there was another issue too, having to do with a problem Iâd noticed in the mid1980s in human visual perception of arrays of colored cells. Somewhat nerdily, I ended up including a note about this in the final NKS book:
But the final conclusion was that, yes, the NKS book would be pure black and white. Nowadaysâparticularly with screen rendering being in many ways more important than printâitâs much easier to do things in color. And, for example, in our Physics Project itâs been very convenient to distinguish types of graphs, or nodes in graphs, by color. But for the NKS book I think it was absolutely the right decision to use black and white. Color might have added some nice accents to certain kinds of diagrams. But the clarityâand visual forceâof the images in the book was much better served by the perceptual crispness of pure black and white.
The way most books with complex formats get produced is that first the author creates âdisembodiedâ pieces of content, then a designer or production artist comes in and arranges them on pages. But for the NKS book I wanted something where the process of creation and layout was much more integrated, and whereâjust as I was directly writing Wolfram Language code to produce imagesâI could also directly lay out final book pages.
By 1990 âdesktop publishingâ was commonplace, and there were plenty of systems that basically allowed one to put anything anywhere on a page. But to make a whole book we knew we needed a more consistent and templated approachâthat could also interact programmatically with the Wolfram Language. There were a few welldeveloped âfullscale book production systemsâ that existed, but they were complex âindustrially orientedâ pieces of software, that didnât seem realistic for me to use interactively while writing the book.
In mid1990, though, we saw a demo of something new, running on the NeXT computer: a system called FrameMaker, which featured bookproduction capabilities, as well as a somewhat streamlined interchange format. Oh, and especially on the NeXT, it handled PostScript graphics well, inserting them âby referenceâ into documents. By late 1990 we were building book layout templates in FrameMaker, and we soon settled on using that for the basic production of the book. (Later, to achieve all the effects we wanted, we ended up having to process everything through Wolfram Language, but thatâs another story.
We iterated for a while on the book design, but by the end of 1991 weâd nailed it down, and I started authoring the book. I made images using Mathematica, importing them in âEncapsulated PostScriptâ into FrameMaker. And words I typed directly into FrameMakerâin the environment reconstructed here using a virtual machine that we saved from the time of authoring the book:
I composed every pageânot only its content, but also its visual appearance. If I had a cellular automaton to render, and it was going to occupy a certain region on a page, I would pick the number of cells and steps to be appropriate for that region. I was constantly adjusting pictures to make them look good on a given page, or on pairs of facing pages, or along with other nearby pictures, and so on.
One of the tricky issues was how to refer to pictures from within the text. In technical books, it’s common to number “figures”, so that the text might say “See Figure 16â. But I wanted to avoid that piece of “scaffolding”, and instead always just be able to say things like “the picture below”, or “the picture on the facing pageâ. It was often quite a puzzle to see how to do this. If a picture was too big, or the text was too small, the picture would get too far ahead, and so on. And I was constantly adjusting things to make everything work.
I also decided that for elegance I wanted to avoid ever having to hyphenate words in the text. And quite often I found myself either rewording things, or slightly changing letter spacing, to make things fit, and to avoid things like “orphaned” words at the beginnings of lines.
It was a strange and painstaking process getting each page to look right, and adjusting content and layout together. Sometimes things got a little pathological. I always wanted to fill out pages, and not to leave space at the bottom (oh, and facing pages had to be exactly the same height). And I also tried to start new sections on a new page. But there I was, writing Chapter 5, and trying to end the section on “Substitution Systems and Fractalsââand I had an empty bottom third of a page. What was I to do? I decided to invent a whole new kind of system, that appears on page 192, just to fill out the layout for page 191:
Looking through my archives, I find traces of other examples. Here are notes on a printout of Chapter 6. And, yes, on page 228 I did insert images of additional rules:
By the end of 1991 I was all set up to author and lay out the book. I started writingâand things went quickly. The first printout I have from that time is from May 1992, and it already has nearly 90 pages of content, with many recognizable pictures from the final NKS book:
✕

At that point the book was titled Computation and the Complexity of Nature, and the chapter titles were a bit different, and rather complexity themed:
✕

A large fraction of the maintext material about cellular automata was already there, as well as material about substitution systems and mobile automata. And there were extensive notes at the end, though at that point they were still singlecolumn, and looked pretty much just like a slightly compressed version of the main text. And, by the way, Turing machines were just then appearing in the book, but still relegated to the notes, on the grounds that they âwerenât as minimal as mobile automataâ.
✕

And hanging out, so far just as a stub, was the Principle of Computational Equivalence:
✕

By August 1992 the book had changed its title to A New Science of Complexity (subtitle: Rethinking the Mechanisms of Nature). There was a new first chapter âSome Fundamental Phenomenaâ that began with photographs of various âsystems from natureâ:
✕

Chapter 3 had now become âThe Behavior of Simple Systemsâ. Turing machines were there. There was at least a stub for register machines and arithmetic systems. But even though Iâd investigated tag systems in September 1991 they werenât yet in the book. Systems based on numbers were starting to be there.
And then, making their first appearance (with the page tagged as having been modified May 25, 1992), were the multiway systems that are now so central to the multicomputational paradigm (or, as I had originally and perhaps more correctly called them in this case, âMultiway Substitution Systemsâ):
✕

By September 1992, register machines were in, complete with the simplest register machine with complex behavior (that had taken a lot of computer time to find). My simple PDE with complex behavior was also there. By early 1993 I had changed its name again, to A Science of Complexity, and had begun to have a quite recognizable chapter structure (though not yet with realistic page numbers):
✕

It imagined a rather different configuration of notes than eventually emerged:
✕

Making its first appearance was a chapter on physics, though still definitely as a stub:
✕

This version of the book opened with âchapter summariesâ, noting about the chapter on fundamental physics that â[Its] high point is probably my (still speculative) attempt to reformulate the foundation of physics in computational terms, including new models for space, time and quantum mechanicsâ:
✕

By February 1994 I was getting bound mockups of the book made, with the final page size, though the wrong title and cover, and at that point only 458 pages (rather than the eventual 1280):
✕

The twocolumn format for the notes at the back was established, and even though the content of notes for the stillcomplexitythemed first chapter were rather different from the way they ended up, some later notes already looked pretty much the same as they would in the final book:
✕

By September 1994 the draft of the book was up to 658 pages. The chapter structure was almost exactly as it finally ended up, albeit also with an epilog, and a bibliography (more about these later):
✕

The September 1994 draft contained a section entitled âThe Story of My Work on Complexityâ (later renamed to the final âThe Personal Story of the Science in this Bookâ) which then included an image of what a Wolfram Notebook on NeXT looked like at the time:
✕

The caption talked about how in the course of the project Iâd generated 3 gigabytes of notebooksâa number which would increase considerably before the book was finished. Charmingly, the caption also said: âThe card at the back of this book gives information about obtaining some of the programs usedâ. Our first corporate website went live on October 7, 1994.
By late 1994 the form of the book was basically all set. Iâd successfully captured pretty much everything Iâd known when I started on the book back in 1991, and Iâd had three years of good discoveries. But what was still to come was seven years of intense research and writing that would take me much further than I had ever imagined back in 1991âand would end up roughly doubling the length of the book.
In 1991 I knew the book I was going to write would have lots of cellular automaton pictures. And I imagined that the main other type of pictures it would contain would be photographs of actual, natural systems. But where was I going to get those photographs from? There was no web with image search back then. We looked at stock photo catalogs, but somehow the kinds of images they had (often oriented towards advertising) were pretty far from what we wanted.
Over the years, I had collectedâalbeit a bit haphazardlyâquite a few relevant images. But we needed many more. I wanted pictures illustrating both complexity, and simplicity. But the good news was that, as I explained early in the book, both are ubiquitous. So it should be easy to find examples of themâthat one could go out and take nice, consistent photographs of.
And starting in late 1991, thatâs just what we did. My archives contain all sorts of negatives and contact prints (yes, this was before digital photography, and, yes, thatâs a boltâintended as an example of simplicity in an artifact):
✕

Sometimes the specimens Iâd want could easily be found in my backyard
✕

or in the sky
✕

or on my desk (and even after waiting 400 million years, the trilobite fossil didnât make it in)
✕

Over the course of a couple of years, Iâd end up visiting all sorts of zoos, museums, labs, aquariums and botanical gardensâas well as taking trips to hardware stores and grocery storesâin search of interesting forms to photograph for the book.
Sometimes it would be a bit challenging to capture things in the field (yes, thatâs a big leaf Iâm holding on the right):
✕

At the zoo, a giraffe took a maddeningly long time to turn around and show me the other side of its patterning (I was very curious how similar they were):
✕

There were efforts to get pictures of âsimple formsâ (yes, thatâs an egg)
✕

with, I now notice, a cameo from meâcaptured in mid experiment:
✕

Sometimes the subjects of photographsâwith simple or complex formsâwere acquired at local grocery stores (did I eat that cookie?):
✕

I cast about far and wide for forms to photographâincluding, I now realize, all of rock, paper and scissors, each illustrating something different:
✕

Sometimes we tried to do actual, physical experiments, here with billiard balls (though in this case looking just like a simulation):
✕

and here with splashes:
✕

✕

I was very interested in trying to illustrate reproducible apparently random behavior. I got a severalfeettall piece of glassware at a surplus store and repeatedly tried dropping dye into water:
✕

I tried looking at smoke rising:
✕

These were all doityourself experiments. But that wasnât always enough. Hereâs a visit to a fluid dynamics lab (yes, with me visible checking out the hydraulic jump):
✕

Iâd simulated flow past an obstacle, but here it was âvisualizedâ in real life:
Then there was the section on fracture. Again, I wanted to understand reproducibility. I got a pure silicon wafer from a physicist friend, then broke it:
✕

Under a powerful microscope, all sorts of interesting structure was visible on the fracture surfaceâthat was useful for model building, even if not obviously reproducible:
✕

And, talking of fractures, in March 1994 I managed to slip on some ice and break my ankle. Had I had pictures of fractures in the book, I was thinking of including an xray of my broken bones:
✕

There are all sorts of stories about photographs that were taken for the book. In illustrating phyllotaxis (ultimately for Chapter 8), I wanted cabbage and broccoli. They were duly obtained from a grocery store, photographed, then eaten by the photographer (who reported that the immortalized cabbage was particularly tasty):
✕

Another thing I studied in the book was shapes of leaves. Back in 1992 Iâd picked up some neighborhood leaves where I was living in California at the time, then done a field trip to a nearby botanical garden. A couple of years laterâbelieving the completion of the book was imminentâI was urgently trying to fill out more entries in a big array of leaf pictures. But I was in the Chicago area, and it was the middle of the winter, with no local leaves to be found. What was I to do? I contacted an employee of ours in Australia. Conveniently it turned out he lived just down the street from the Melbourne botanical gardens. And there he found all sorts of interesting leavesâmaking my final page a curious mixture of Californian and Australian fauna:
✕

As it turned out, by the next spring I hadnât yet finished the book, and in fact I was still trying to fill in some of what I wanted to say about leaves. I had a model for leaf growth, but I wanted to validate it by seeing how leaves actually grow. That turned out not to be so easyâthough I did dissect many leaf buds in the process. (And it was very convenient that this was a plantrelated question, because Iâm horribly squeamish when it comes to dissecting animals, even for food.)
Some of what I wanted to photograph was out in the world. But some was also collectible. Ever since I was a kid I had been gradually acquiring interesting shells, fossils, rocks and so on, sometimes âout in the fieldâ, but more often at shops. Working on the NKS book I dramatically accelerated that process. Shells were a particular focus, and I soon got to the point where I had specimens of most of the general kinds with âinteresting formsâ. But there were still plenty of adventuresâlike finding my very best sample of âcellularautomatonlikeâ patterning, on a false melon volute shell tucked away at the back of a store in Florida:
✕

In 1998 I was working on the section of the book about biological growth, and wanted to understand the space of shell shapes. I was living in the Chicago area at that time, and spent a lovely afternoon with the curator of molluscs at the Field Museum of Natural Historyâgradually trying to fill in (with a story for every mollusc!) what became the array on page 416 of the book:
✕

And actually it turned out that my own shell collection (with one exception, later remedied) already contained all the necessary speciesâand in a drawer in my office I still have the particular shells that were immortalized on that page:
✕

I started to do the same kind of shape analysis for leavesâbut never finished it, and it remains an open project even now:
✕

My original conception had been to start the book with âthings we see in nature and elsewhereâ and then work towards models and ideas of computation. But when I switched to âcomputation firstâ I briefly considered going to more âabstracted photographsâ, for example by stippling:
✕

But in the end I decided thatâjust like my images of computational systemsâany photographs should be as âdirect as possibleâ. And they wouldnât be at the beginning of the book, but instead would be concentrated in a specific later chapter (Chapter 8: “Implications for Everyday Systems”). Pictures of things like bolts and scissors became irrelevant, but by then Iâd accumulated quite a library of images to choose from:
✕

Many of these images did get used, but there were some nice collections, that never made it into the book because I decided to cut the sections that would discuss them. There were the âthings that look similarâ arrays:
✕

And there were things like pollen grains or mineralrelated forms (and, yes, I personally crystallized that bismuth, which did at least make it into the notes):
✕

✕

There were all sorts of unexpected challenges. I wanted an array of pictures of animals, to illustrate their range of pigmentation patterns. But so many of the pictures we could find (including ones Iâd taken myself) we couldnât useâbecause I considered the facial expressions of the animals just too distracting.
And then there were stories like the “wild goose chase”. I was sure I’d seen a picture of migrating birds (perhaps geese) in a nested, SierpiĆskilike pattern. But try as we might, we couldn’t find any trace of this.
But finally I began to assemble pictures into the arrays we were going to use. In the end, only a tiny fraction of the ânatureâ pictures we had made it into the book (and, for example, neither the egg nor the phyllotactically scaled pangolin here did)âsome because they didnât seem clear in what they were illustrating, and some because they just didnât fit in with the final narrative:
✕

Beyond the natural world, the more I explored simple programs and what they can do, the more I wondered why so many of the remarkable things I was discovering hadn’t been discovered before. And as part of that, I was curious what kinds of patterns people had in fact constructed from rules, for art or otherwise. On a few occasions during the time I was working on the book, I managed to visit relevant museums, searching for unexpected patterns made by rules:
✕

✕

But mostly all I could do was scour books on art history (and architecture) looking for relevant pictures (and, yes, it was books at the timeâand in fact the web didn’t immediately help even when it became available). Sometimes I would find a clear picture, and we would just ask for permission to reproduce it. But often I was interested in something that was for example off on the side in all the pictures we could find. So that meant we had to get our own pictures, and occasionally that was something of an adventure. Like when we got an employee of ours who happened to be vacationing in Italy to go to part of an obscure church in rural Italyâand get a photograph of a mosaic there from 1226 AD (and, yes, those are our photographer’s feet):
✕

When I started working on the book in 1991 I saw it as an extension of what Iâd done in the 1980s to establish a âscience of complexityâ. So at first I simply called the book The Science of Complexity, adding the explanatory subtitle A Unified Approach to Complex Behavior in Natural and Artificial Systems. But after a while I began to feel that this sounded a bit stodgyâand like a textbookâso to spruce it up a bit I changed it to A New Science of Complexity, with subtitle Rethinking the Mechanisms of Nature:
✕

Pretty soon, though, I dropped the âNewâ as superfluous, and the title became A Science of Complexity. I always knew computation was a key part of the story, but as I began to understand more about just what was out there in the computational universe, I started thinking I should capture âcomputationâ in the name of the book, leading to a new idea: Computation and the Complexity of Nature. And for this title I even had a first cover draft madeâcomplete with an eye, added on the theory that human visual perception would draw people to the eye, and thus make them notice the book:
✕

But back in 1992 (and I think it would be different today) people really didnât understand the term âcomputationâ, and it just made the book sound very technical to them. So back I went to A Science of Complexity. I wasnât very happy with it, though, and I kept on thinking about alternatives. In August 1992 I prepared a little survey:
✕

The results of this survey wereâlike those of many surveysâinconclusive, and didnât change my mind about the title. Still, in October 1992 I dashed off an email considering The Inevitable Complexity of Nature and Computation. But 15 minutes later, as I put it, I’d “lost interest” in that, and it was back to A Science of Complexity.
By 1993, believing that the completion of the book was somehow imminent, weâd started trying to mock up the complete look of the book, including things like the back cover, and cover flaps:
✕

The flap copy began: âThis book is about a new kind of science that…â. In the first chapter there was then a section called âThe Need for a New Kind of Scienceâ:
✕

As 1993 turned into 1994 I was still working with great intensity on the book, leaving almost no time to be out and about, talking about what I was doing. Occasionally, though, I would run into people and they would ask me what I was working on, and I would say it was a book, titled A Science of Complexity. And when I said thatâat least among nontechnical peopleâthe reaction was essentially always the same âOh, that sounds very complicatedâ. And that would be the end of the conversation.
By September 1994 this had happened just too many times, and I realized I needed a new title. So I thought to myself “How would I describe the book?”. And there it was, right in the flap copy: “a new kind of scienceâ. I made a quick note on the back of my then business card:
✕

And soon that was the title: A New Kind of Science. I started trying it out. The reaction was again almost always the same. But now it was âSo, whatâs new about it?â And that would start a conversation.
I liked the title a lot. It definitely said what by then I thought the book was about. But there was one thing I didnât like. It seemed a bit like a âmeta titleâ. OK, so you have a new kind of science. But what is that new kind of science called? What is its name? And why isnât the book called that?
I spent countless hours thinking about this. I thought about word roots. I considered comp (for âcomputationâ), prog (for âprogramâ), auto (for âautomataâ, etc.). I went through Latin and Greek dictionaries, and considered roots like arch and log (both way too confusing). I wrote programs to generate âsynthetic wordsâ that might evoke the right meaning. I considered names like âalgonomicsâ, âgramistryâ, âregulisticsâ (but not âruliologyâ!), and âprogramisticsââfor which I tried to see how its usage might work:
✕

But nothing quite clicked. And in a sense my working title already told me why: I was talking about âa new kind of scienceâ, which involved a new way of thinking, for which there were really no words, because it hadnât been done before.
Iâd had a certain amount of experience inventing words, for concepts in both science and technology. Sometimes it had gone well, sometimes not so well. And I knew the same was true in general in history. For every âphysicsâ or âeconomicsâ or even âcyberneticsâ there were countless names that had never made it.
And eventually I decided that even if I could come up with a name, it wasnât worth the risk. Maybe a name would eventually emerge, and it would be perfectly OK if the âlaunch bookâ was called A New Kind of Science (as yet unnamed). Certainly much better than if it gave the new kind of science a definite name, but the name that stuck was different.
During the writing of A New Kind of Science, I didnât really need to ârefer in the third personâ to what the book was about. But pretty much as soon as the book was published, there needed to be a name for the intellectual endeavor that the book was about. During the development of the book, some of the people working on its project management had started calling the book by the initials of its title: ANKOS. And that was the seed for the name of its content, which almost immediately became âNKSâ.
Over the years, Iâve returned quite a few times to the question of naming. And very recently Iâve started using the term “ruliology” for one of the key pursuits of NKS: exploring the details of what systems based on simple computational rules do. I like the name, and I think it captures well the ethos of the specific scientific activity around studying the consequences of simple rules. But itâs not the whole story of âNKSâ. A New Kind of Science is, as its name suggests, about a new kind of scienceâand a new way of thinking about the kind of thing we imagine science can be about.
When the book was first published, some people definitely seemed to feel that the strength and simplicity of the title âA New Kind of Scienceâ must claim too much. But twenty years later, I think itâs clear that the title said it right. And itâs charming now when people talk about whatâs in A New Kind of Science, and how itâs different from other things, and want to find a way to say what it isâand end up finding themselves saying it’s “a new kind of science”. And, yes, thatâs why I called the book that!
We started thinking about the cover of the book very early in the projectâwith the âeyeâ design being the first candidate. But considering this a bit too surreal, the next candidate designs were more staid. The title still wasnât settled, but in the fall of 1992 a few covers were tried:
✕

I thought these covers looked a bit drab, so we brightened them up, and by 1993âand after a few âcolor explorationsâ
✕

we had a “working cover” for the book (complete with its working title), carrying over typography from the previous designs, but now featuring an image of rule 30 together with the “mascot of the project”: a textile cone shell with a rule30like pigmentation pattern:
✕

When I changed the title in 1994, the change was swiftly executed on the coverâwith my draft copy from the time being a charming palimpsest with A New Kind of Science pasted over A Science of Complexity:
✕

I was never particularly happy with this cover, though. I thought it was a bit âstaticâ, particularly with all those boxedin elements. And compared to other âpopular booksâ in bookstores at the time, it was a very âquietâ cover. My book designer tried to âamp it upâ
✕

sometimes still with a hint of mollusc
✕

âNot that loud!â, I said. So he quietened it down, but now with the type getting a bit more dynamic:
✕

Then a bit of a breakthrough: just type and cellular automaton (now rule 110):
✕

It was nice and simple. But now it seemed perhaps too quiet. We punched up the type, just leaving the cellular automaton as a kind of decoration:
✕

And there were a variety of ways to handle the type (maybe even with an emphasized subtitleâcomplete with a designerâs misspelling):
✕

But the important point was that weâd basically backed into an idea: why not just use the natural angles of the structures in rule 110 to delimit the cellular automaton on the cover? As so often happens, the computational universe had âspontaneouslyâ thrown up a good idea that we hadnât thought of.
I didnât think the cover was quite âthereâ, but it was making progress. Right around this time, though, we were in discussions with a big New York publisher about them publishing the book, and they were trying to sell us on the value they could add. They were particularly keen to show us their prowess at cover design. We patiently explained that we had quite a large and good art department, which happened to have even recently won some national awards for design.
But the publisher was sure they could do better. I remember saying: “Go ahead and tryââ and then adding, “But please don’t show us something from someone who has no idea what kind of a book this is.â
Several weeks later, with some fanfare, they produced their proposal:
✕

Yup, mollusc shells can be found on beaches. But this wasnât a âbeachreading novelâ kind of book. And it would be an understatement to say we werenât impressed.
So, OK, it was on us: as Iâd expected, weâd have to come up with a cover design. My notes arenât dated, but sometime around then I started thinking harder about the design myself. I was playing around with rule 30, imagining a âphysicalizedâ version of it (with 3D, letters casting shadows, etc.):
✕

I find in my archives some undated sketches of further âphysicalizedâ cover concepts (or, at least I assume they were cover concepts, and, yes, sadly Iâve never learned to draw, and I canât even imagine who that dude was supposed to be):
✕

But then we had an idea: maybe the strangely shaped triangle could be like a shaft of light illuminating a cellular automaton image. We talked about the metaphor of the science âproviding illuminationâ. I was very taken with the notion that the basic ideas of the science could have been discovered even in ancient times. And that made us think about cellular automaton markings in a cave, suddenly being illuminated by an archaeologistâs flashlight. But how would we make a picture of something like that?
We tried some âstone effectsâ:
✕

We investigated finding a stone mason who could carve a cellular automaton pattern into something like a gravestone. (3D printing wasn’t a thing yet.) We even tried some photographic experiments. But with the cellular automaton pattern itself having all sorts of fine detail, one barely even noticed a stone texture. And so we went back to pure computer graphics, but now with a “shaft of light” motif:
✕

It wasnât quite right, but it was getting closer. Meanwhile, the New York publisher wanted to have another try. Their new, âspiffierâ proposal (offering type alternatives for âextra creditâ) was:
✕

(The shell, now shrunk, was being kept because their sales team was enamored of the idea of a tiein whereby they would give physical shells to bookseller sales prospects.)
OK, so how were we going to tune up the cover? The cellular automaton triangle wasnât yet really looking much like a shaft of light. It was something to do with the edges, we thought:
✕

It was definitely very subtle. We tried different angles and colors:
✕

We tried, and rejected, sans serif, and even partial sans serif:
✕

And by July 1995 the transition was basically complete, and for the first time our draft printouts started looking (at least on the outside) very much like modern NKS books:
✕

Specifying just what color should be printed was pretty subtle, and over the months that followed we continued to tweak, particularly the âshaft of lightâ
✕

until eventually A New Kind of Science got its final cover:
✕

All along weâd also been thinking about what would show up on the spine of the bookâand occasionally testing it in an âidentity paradeâ on a bookshelf. And as soon as we had the âshaft of lightâ idea, we immediately thought of it wrapping around onto the spine:
✕

Part of what makes the cover work is the specific cellular automaton pattern it usesâwhich, in characteristic form, I explained in the notes (and, yes, the necessary initial conditions were found by a search, and are now in the Wolfram Data Repository):
✕

How should the NKS book begin? When I write something I always like to start writing at the beginning, and I always like to say âup frontâ what the main point is. But over the decade that I worked on the NKS book, the âmain pointâ expandedâand I ended up coming back and rewriting the beginning of the book quite a few times.
In the early years, it was pretty much all about complexityâthough even in 1991 the term âa new kind of scienceâ already makes an appearance in the text:
✕

In 1993, I considered a more âshow, donât tellâ approach that would be based on photographs of simple and complex forms:
✕

But soon the pictures were gone, and I began to concentrate more on how what I was doing fitted into the historical arc of the development of scienceâthough still under a banner of complexity:
✕

After my 1996 hiatus (spent finishing Mathematica 3.0) the text of the opening section hadnât changed, but the title was now âThe Need for a New Kind of Scienceâ:
✕

And I was soon moving further away from complexity, treating it more as âjust an important exampleâ:
✕

Then, in 1999, âcomplexityâ drops out of the opening paragraphs entirely, and it becomes all about methodology and the arc of history:
✕

And in fact from there on out the first couple of paragraphs donât changeâthough the section title softens, taking out the explicit mention of ârevolutionâ:
✕

Itâs interesting to notice that even though until perhaps 1998 before the opening of the book reflected âmoving away from complexityâ, other things I was writing already had. Here, for example, is a candidate âcover blurbâ that I wrote on January 11, 1992 (yes, a decade early):
✕

And as I pull this out of my archives, I notice at the bottom of it:
✕

Hmm. That would have been interesting. But another 400 pages?
By the end of 1991 the basic concept of what would become A New Kind of Science was fairly clear. At the time, I still thoughtâas I had in the 1980sâthat the best âhookâ was the objective of âexplaining complexityâ. But I perfectly well understood that from an intellectual and methodological point of view the most important part of the story was that I was starting to truly take seriously the notion of computationâand starting to think broadly in a fundamentally computational way.
But what could be figured out like this? What about systems based on constraints? What about systems that adapt or learn? What about biological evolution? What about fundamental physics? What about the foundations of mathematics? At the outset, I really didnât know whether my approach would have anything to say about these things. But I thought I should at least try to check each of them out. And what happened was that every time I turned over a (metaphorical) rock it seemed like I discovered a whole new world underneath.
It was intellectually excitingâand almost addictive. I would get into some new area and think âOK, let me see what I can figure out here, then move onâ. But then I would get deeper and deeper into it, and weeks would turn into months, and months would turn into years. At the beginning I would sometimes tell people what I was up to. And they would say âThat sounds interesting. But what about X, Y, Z?â And I would think âI might as well try and answer those questions tooâ. But I soon realized that I shouldnât be letting myself get distracted: I already had more than enough very central questions to answer.
And so I decided to pretty much âgo hermitâ until the book was done. An email I sent on October 1, 1992, summarizes how I was thinking at the time:
✕

But that email was right before I discovered yet more kinds of computational systems to explore, and before Iâd understood applications to biology, and physics, and mathematics, and so on.
In the early years of the project Iâd had various âI could do that as wellâ ideas. In 1991 I thought about dashing off an Introduction to Computing book (maybe I should do that now!). In 1992 I had a plan for creating an email directory for the world (a very proto LinkedIn). In 1993 I thought about TIX: âThe Information Exchangeâ (a proto web for computable documents).
But thinking even a little about these things basically just showed me how much what I really wanted to do was move forward on the science and the book. I was still energetically remoteCEOing my company. But every day, by midevening, I would get down to science, and work on it through much of the night. And pretty much thatâs how I spent the better part of a decade.
My personal analytics data of outgoing emails show that during the time I was working on the book I became increasingly nocturnal (I shifted and âstabilizedâ after the book was finished):
✕

I had started the NKS book right after the big push to release Mathematica 2.0. And thinking the book would take a year or maybe 18 months I figured it would be long finished before there was a new version of Mathematica, and another big push was needed. But it was not to be. And while I held off as long as I could, by 1996 there was no choice: I had to jump into finishing Mathematica 3.0.
From the beginning until now Iâve always been the ultimate architect of whatâs now the Wolfram Language. And back in the 1990s my way of defining the specification for the language was to write its documentation, as a book. So getting Mathematica 3.0 out required me writing a new edition of The Mathematica Book. And since we were adding a lot in Version 3, the book was longâeventually clocking in at 1403 pages. And it took me a good part of 1996 to write it.
But in September 1996, Mathematica 3.0 was released, and I was able to go back to my intense focus on science and the NKS book. In many ways it was exhilarating. With Wolfram Language as a tool, I was powering through so much research. But it was difficult stuff. And getting everything rightâand as clear as possibleâwas painstaking, if ultimately deeply satisfying, work. On a good day I might manage to write one page of the book. Other times I might spend many days working out what would end up as just a single paragraph in the notes at the back of the book.
I kept on thinking âOK, in just a few months itâll be finishedâ. But I just kept on discovering more and more. And finding out again and again that sections in the table of contents that I thought would just be âquick notesâ actually led to major research projects with all sorts of important and unexpected results.
A 1995 picture captured my typical working setup:
✕

A year or so later, I had the desk Iâm still sitting at today (though not in the same location), and a (rarely used) webcam had appeared:
✕

A few years after that, the computer monitor was thinner, two young helpers had arrived, and I was looking distinctly unkempt and hermitlike:
✕

In 2000 a photographer for Forbes captured my âcaged scientistâ look
✕

along with a rather nice artistically lit âstill lifeâ of my working environment (complete with a âfromthefutureâ thickerthanreallife mockup of the NKS book):
✕

But gradually, inexorably, the book got closer and closer to being finished. The floor of my office had been covered with piles of paper, each marked with whatever issue or unfinished section they related to. But by 2001 the piles were disappearingâand by the fall of that year they were all but gone: a visible sign that the book was nearing completion.
A New Kind of Science isâas its title suggestsâa book about new things. But an important part of explaining new things is to provide context for them. And for me a key part of the context for things is always the story of what led to them. And that was something I wanted to capture in the NKS book.
Typically there were two parts: a personal narrative of how I was led to somethingâand a historical narrative of what in the past might connect to it. The academic writing style that Iâd adopted in the 1980s really didnât capture either of these. So for the NKS book I needed a new style. And there were again two parts to this. First, I needed to âput myself into the textâ, describing in the first person how Iâd reached conclusions, and what their importance to me was. And second, I needed to âtell the storyâ of whatever historical developments were relevant.
Early on, I made the decision not to mix these kinds of narratives. I would talk about my own relation to the material. And I would talk about other people and their historical relation to the material. But I didnât talk about my interactions with other people. And, yes, there are lots of wonderful stories to tellâwhich perhaps one day Iâll have a chance to systematically write down. But for the NKS book I decided that these storiesâwhile potentially fun to readâjust werenât relevant to the absorption and contextualization of what I had to say. So, with a bit of regret, I left them out.
In typical academic papers one references other work by inserting pure, uncommented citations to it. And deep within some welldeveloped field, this is potentially an adequate thing to do. Because in such a field, the structure is in a sense already laid out, so a pure citation is enough to explain the connection. But for the NKS book it was quite different. Because most of the time the historical antecedents were necessarily done in quite different conceptual frameworksâand typically the only reasonable way to see the connection to them was to tell the story of what was done and why, recontextualized in an âNKS wayâ.
And what this meant was that in writing the NKS book, I ended up doing a huge amount of âscholarshipâ, tracking down history, and trying to piece together the stories of what happened and why. Sometimes I personally knewâor had knownâthe people involved. Sometimes I was dealing with things that had happened centuries ago. Often there were mysteries involved. How did this person come to be thinking about this? Why didnât they figure thisorthat out? What really was their conceptual framework?
Iâve always been a person who tries to âdo my homeworkâ in any field Iâm studying. I want to know both whatâs known, and whatâs not known. I want to get a sense of the patterns of thinking in the field, and âvalue systemsâ of the field. Many times in working on the NKS book I got the sense that thisorthat field should be relevant. But what was important for the NKS book was often something that was a footnoteâor was even implicitly ignoredâby the field. And it also didnât help that the names for things in particular fields were often informed by their specific uses there, and didnât connect with what was natural for the NKS book.
I started the NKS book shortly after the web was invented, and well before there was substantial content on it. So at least at first a lot of my research had to be done the same way Iâd done it in the 1980s: from printed books and papers, and by using online and printed abstracting systems. Hereâs part of a âsearchâ from 1991 for papers with the keyword âautomataâ:
✕

By the end of writing the NKS book Iâd accumulated nearly 5000 books, a few of them pictured here in their thenhabitat circa 1999 (complete with me at my Iâvebeenonthisprojecttoolong lifetimemaximum weight):
✕

I had an online catalog of all my books, which I put online soon after the NKS book was published. I also had file cabinets filled with more than 7000 papers. Perhaps it might have been nice when the NKS book was published to be able to say in a kind of traditional academic style âhere are the âcitationsââ (and, finally, 20 years later weâre about to be able to actually do that). But at the time it wasnât the simple citations I wanted, or thought would be useful; it was the narrative I could piece together from them.
And sometimes the papers werenât enough, and I had to make requests from document archives, or actually interview people. It was hard work, with a steady stream of surprises. For example, in Stan Ulamâs archives we found a (somewhat scurrilous) behindthescenes interaction about me. And after many hours of discussion John Conway admitted to me that his usual story about the origin of the Game of Life wasn’t correctâthough I at least found the true story much more interesting (even if some mystery still remains). There were times when the things I wanted to know were still entangled in government or other secrecy. And there were times when people had just outright forgotten, often because the things I now cared about just hadnât seemed important beforeâand now could only be recovered by painstakingly âtriangulatingâ from other recollections and documents.
There were so many corners to the scholarship involved in creating the NKS book. One memorable example was what we called the âPeople Datesâ project. I wanted the index to include not only the name of every person I mentioned in the book, but also their dates, and the primary country or countries in which they worked, as in âWolfram, Stephen (England/USA, 1959– ).â
For some people that information was straightforward enough to find. But for other people there were challenges. There were 484 people altogether in the index, with a roughly exponentially increasing number born after about 1800:
✕

For ones who were alive we just sent them email, usually getting helpful (if sometimes witty) responses. In other cases we had to search government records, ask institutions, or find relatives or other personal contacts. There were lots of weird issues about transliterations, historical country designations, and definitions of “worked in”. But in the end we basically got everything (though for example Moses SchĂ¶nfinkelâs date of death remained a mystery, as it does even now, after all my recent research).
Most of the historical research I did for the NKS book wound up in notes at the back of the book. But of all the 1350 notes spread over 348 smallprint pages, only 102 were in the end historical. The other notes covered a remarkable range of subject matter. They provided background information, technical details and additional results. And in many ways the notes represent the highest density of information in the NKS bookâand I, for example, constantly find myself referring to them, and to their pithy (and, I think, rather clear) summaries of all sorts of things.
When I was working on the book there were often things I thought Iâd better figure out, just in case they were relevant to the core narrative of the book. Sometimes theyâd be difficult things, and theyâd take meâand my computersâdays or even weeks. But quite often what came out just didnât fit into the core narrative of the book, or its main text. And so the results were relegated to notes. Maybe thereâll just be one sentence in the notes making some statement. But behind that statement was a lot of work.
Many times I would have liked to have had ânotes to the notesâ. But I restrained myself from adding yet more to the project. Even though today Iâve sometimes found myself writing even hundreds of pages to expand on what in the NKS book is just a note, or even a part of a note.
The 1990s spanned the time from the very beginning of the web to the point where the web had a few million pages of content. And by the later years of the project I was making use of the web whenever I could. But often the background facts I needed for the notes were so obscure that there was nothing coherent about them on the webâand in fact even today itâs common for the notes to the NKS book to be the best summaries to be found anywhere.
I figured, though, that the existence of the web could at least âget me off the hookâ on some work I might otherwise have had to do. For example, I didn’t think there was any point in giving explicit citations to documents. I made sure to include relevant names of people and topics. Then it seemed as if itâd be much better just to search for those on the web, and find all relevant documents, than for me to do all sorts of additional scholarship trying to pick out particular citations that then someone might have to go to a library to look up.
Iâm not sure when I could say that the finishing of the NKS book finally seemed in sight. Weâd been making bound book mockups since early 1994. Looking through them now itâs interesting to see how different parts gradually came together. In July 1995, for example, there was already a section in Chapter 9 on “The Nature of Space”, but it was followed by a section on the âNature of Timeâ that was just a few rough notes. Thereâs a hiatus in mockups in 1996 (when I was working on Mathematica 3.0) but when the mockups pick up again in January 1997ânow bound in three volumesâthereâs a section on âThe Nature of Timeâ containing an early (and probably not very good) idea based on multiway systems that Iâd long since forgotten (later âThe Nature of Timeâ section would be broken into different sections):
✕

Already in 1997 thereâs a very rough skeleton of Chapter 12âwith a fairly accurate collection of section headings, but just 18 pages of rather rough notes as content. Meanwhile, thereâs a postChapter12 âEpilogâ that sprouts up, to be dropped only late in the project (see below). Chapter 12 begins to âbulk upâ in late 1999, and in 2000 really âtakes offâ, for example adding the long section on “Implications for the Foundations of Mathematics”. At that point our rate of making book mockups began to pick up. Weâd been indicating different mockups with dates and colored labeling (âthe banana versionâ, etc.) But, finally, dated February 14, 2001, thereâs a version labeled (in imitation of software release nomenclature) âAlpha 1â.
And by then I was starting to make serious use of the machinery for doing large projects that weâd developed for so many years at Wolfram Research. The âNKS Projectâ started having project managers, build systems and internal websites (yes, with garish web colors of the time):
✕

Weâd had the source for the book in a source control system for several years, but as far as I was concerned the ultimate source for the book was my filesystem, and a specific set of directories that, yes, are still there in my filesystem all these years later:
✕

Everything was laid out by chapter and section. Text contained the FrameMaker files. Notebooks contained the source notebooks for all the diagrams (with longtocompute results prestored in Results):
✕

The workflow was that every diagram was created in Wolfram Language, then saved as an EPS file. (EPS or “Encapsulated PostScript” was a forerunner of PDF.) And gradually, over the course of years, more and more EPS files were generated, here reconstructed in the order of their generation, starting around 1994:
In creating all these EPS files, there was lots of detailed tweaking done, for example in the exact (programmatically specified) sizes for the images given in the files. We’d built up a whole diagramgenerating system, with all sorts of detailed standards for sizings and spacings and so on. And several timesâparticularly as a result of discovering quirks in the printing processâwe decided we had to change the standards we were using. This could have been a projectderailing disaster. But because we had everything programmatically set up in notebooks it was actually quite straightforward to just go through and automatically regenerate the thousand or so images in the book.
Each EPS file that was generated was put in a Graphics directory, then imported (âby referenceâ) by FrameMaker into the appropriate page of the book. And the result was something that looked almost like the final NKS book. But there were two âlittleâ wrinkles, that ended up leading to quite a bit of technical complexity.
The first had to with the fragments of Wolfram Language code in the notes. At the time it was typical to show code in a simple monospaced font like Courier. But I thought this looked uglyâand threw away much of the effort Iâd put into making the code as elegant and readable as possible. So I decided we needed a different code font, and in particular a proportionally spaced sans serif one. But there was a technical problem with this. Many of the characters we needed for the code were available in any reasonable font. But some characters were special to the Wolfram Languageâor at least were characters that for example weâd been responsible for being included in the Unicode standard, and werenât yet widely supported in fonts.
And the result was that in addition to all the other complexities of producing the book we had to design our own font, just for the book:
✕

But that wasnât all. In Mathematica 3.0 we had invented an elaborate typesetting system which carefully formatted Wolfram Language code, breaking it into multiple lines if necessary. But how were we to weave that nicely formatted code into the layouts of pages in FrameMaker? In the end we had to use Wolfram Language to do this. The way this worked is that first we exported the whole book from FrameMaker in âMaker Interchange Formatâ (MIF). Then we parsed the resulting MIF file in Wolfram Language, in effect turning the whole book into a big symbolic expression. At that point we could use whatever Wolfram Language functionality we wanted, doing various patternmatchingbased transformations and typesetting each of the pieces of code. (We also handled various aspects of the index at this stage.) Then we took the symbolic expression, converted it to MIF, and imported it back into FrameMaker.
In the end the production of the book was handled by an automated build scriptâjust like the ones we used to build Mathematica (the full build log is 11 pages long):
✕

But, OK, so by early 2001 we were well on the way to setting all these technical systems up. But there was more to do in âproducing the bookââas indicated for example by the various column headings in the project management internal website. âGraphics regeneratedâ was about regenerating all the EPS files with the final standards for the book. âMicrotweakingâ was about making sure the placement of all the graphics was just right. Then there were various kinds of what in our company we call âdocument quality assuranceâ, or DQAâchecking every detail of the document, from grammar and spelling to overall consistency and formatting. (And, yes, developing a style guide that worked with my sometimesnonstandardâbut I believe highly sensible!âwriting conventions.)
In addition to checking the form of the book, there was also the question of checking the content. Much of thatâincluding extensive fact checking, etc.âhad gone on throughout the development of the book. But near the end one more piece of checking had to do with the code that was included in the book itself. Our company has had a long history of sophisticated software quality assurance (âSQAâ), and I applied that to the bookâfor example having extensive tests written for all the code in the book.
Much like for software, once we reached the first âAlpha versionâ of the book we also started sending it out to external âalpha testersââand got a modest but helpful collection of responses. We had several pages of instructions for our âtestersâ (that we called âreadersâ since, after all, this was a book):
✕

After the âAlpha 1â version of the book in February 2001, there followed six more âAlphaâ versions. In âAlpha 1â there were still XXXXâs scattered around the text, alignment and other issues in graphicsâand some of the more âphilosophicalâ sections in the book were just in note form, crossed out with big Xâs in the printout. But in the course of 2001 all these issues got ironed out. And on January 15, 2002, I finished and dated the preface.
Then on February 4, 2002, we produced the “Beta 1” version of the bookâand began to make final preparations for its printing and publication. It had been a long road, illustrated by the sequence of intermediate versions weâd generated, but we were nearing the end:
✕

I like indices, and the index to the NKS bookâwith its 14,967 entriesâis my alltime favorite. In these times of ubiquitous fulltext search one might think that a book index would just be a quaint relic of the past (and indeed some younger people donât even seem to know that most books have indices!). But it definitely isnât with the NKS book. And indeed when I want to find something in the book, the place I always turn first is the index (now online).
I started creating the index to the NKS book in the spring of 1999, and finished it right before the final version of the book was produced in February 2002. I had already had the experience of creating indices to five editions of The Mathematica Book, and had seen the importance of those indices in peopleâs actual use of Mathematica. I had developed various theories about how to make a good indexâwhich sometimes differed from conventional wisdomâbut seemed to work rather well.
A good index, I believe, should list whatever terms one might actually think of looking up, regardless of whether itâs those literal termsâor just synonyms for themâthat appear in the text. If thereâs a phrase (like âfinite automataâ) explicitly list it in all the ways people might think of it (âfinite automataâ, âautomata, finiteâ), rather than having some âtheoryâ (that the users of the index are very unlikely to know) about how to list the phrase. And perhaps most important, generously include subterms, âsubdividingâ until each individual entry references at most a few pages. Because when youâre looking for something, you want to be able to zero in on a particular page, not be confronted with lots of âpotentially relevantâ pages. And wellchosen subterms immediately give a kind of pointillistic map of the coverage of some area.
Iâve always enjoyed creating indices. For me itâs an interesting exercise in quickly organizing knowledge and identifying whatâs important, as well as engaging in rapid âwhat are different ways to say that?â association. (And, yes, a similar skill is needed in linguistic curation for the natural language understanding system of WolframAlpha.) For the NKS book (and other indices) my basic strategy was to go through the book page by page, adding tags for index entries. But what about consistency? Did I just index âFig leavesâ in one place, and somewhere else index âLeaves, figâ instead? We built Wolfram Language code to identify such issues. But eventually I just generated the alphabetical index, and read through it. And then had Wolfram Language code that could realign tags to correct the source of whatever fixes I madeâwhich most often related to subterms.
At first I broke the index into an ordinary âIndexâ and an âIndex of Namesâ. But what counted as a ânameâ? Only a personâs name? Or also a place name? Or also ârule 30â? Within a couple of months I had combined everything into an âIndex of words, names, concepts and systemsââwhich soon became headed just âIndexâ (with a pointer to a note about what was in it).
The final index is remarkably eclecticâreflecting of course the content of the book. After âField theory (physics)â comes âFields (agricultural)â, followed by âFifths (musical chords)â and so on:
✕

In the end the indexâeven printed as it was in 4 columnsâran to 80 pages (or more than 6% of the book). It was obviously a very useful index, and it could even be entertaining to read, not only for its eclectic jumps from one term to the next, but also for the unexpected terms that appeared. Whatâs âFlash photographyâ or âFlint arrowheadsâ doing there, or âFrogsâ for that matter? What do these terms have to do with a new kind of science?
But for all its value, I was a bit concerned that the index might be so long that it finally made the book âtoo longâ. Even without the index the book ran to 1197 pages. But why tell people, I thought, that the whole book is really 1280 pages, including the index? If the pages of the index were numbered, then one could immediately see the number of that last page. But why number the pages of an index? Nobody needs to refer to those pages by numbers; if anything, just use the alphabetized terms. So I decided just quietly to omit the page numbers of the index, so we could report the length of the book as 1192 pages.
OK, so A New Kind of Science was going to be a book. But how was it going to be published? At the time I started writing A New Kind of Science in 1991 the second edition of The Mathematica Book had just been released, and its publisher (AddisonWesley) seemed to be doing a good job with it. So it was natural to start talking about my new book with the same publisher. I was quite aware that AddisonWesley was primarily a publisher of textbooklike books, and in fact the particular division of AddisonWesley that had published The Mathematica Book was more oriented towards monographs and special projects. But the success of The Mathematica Book generated what seemed like good corporate interest in trying to publish my new book.
But how would the details work? There were immediate questions even about printing the book. I knew the book would rely heavily on graphics which would need to be printed well. But to print them how they needed to be printed was expensive. So how would that work financially? (And at that point I didnât yet even know that the book would also be more than a thousand pages long.)
The basic business model of publishing tends to be: invest up front in making a book, then (hopefully) make money by selling the book. And for most authors, the book canât happen without that upfront investment. But that wasnât my situation. I didnât need an advance to support myself while writing the book. I didnât need someone to pay for the production of the book. And if necessary I could even make the investment myself to print the books. But what I thought I needed from a publisher was access to distribution channels. I needed someone to actually sell books to bookstores. I needed there to be a sales team that had relationships with bookstore chains, and that would do things like actually visit bookstores and get books into them.
And in fact quite a lot of the early discussion about the publishing of the book centered around how salespeople would present it. How would the book be positioned relative to the wellknown âpopular scienceâ books of the time? (That positioning would be key to the size of initial purchases bookstores might make.) What special ways might the salespeople make the book memorable? Could we get enough textile cone shells that the salespeople could drop one off at every bookstore they visited? (The answer, it was determined, was yes: in the Philippines such shells were quite plentiful.)
But how exactly would the numbers work? Bookstores took a huge cut (often above 50%). And if the book was expensive to print, that didnât leave much of a margin. At least at the time, the publishing industry was very much based on formulas. If you spend $x to print a book, you need to spend $y on marketing, and you pay the author $y (yes, same y) as an advance on royalties. For the author, the advance serves as a kind of guarantee of the publisherâs effortâsince unless the book sells, the publisher just loses that money.
Well, I most definitely wanted a guarantee that the publisher would put effort in. But I didnât need or want an advance; I just wanted the publisher to put as much as possible into distribution. Around and around it went, trying to see how that might work. Exasperated, I found an expert on book deals. They didnât seem to be able to figure it out either. And I began to think: perhaps I should go to a different publisher, maybe one more familiar with widely distributed books.
Itâs typical for authors not to interact directly with such publishers, but instead to go through an agent. In principle that allows authors not to have to exercise business savvy, and publishers not to be exposed to the foibles of authors. But I just wanted to make whatâat least by tech industry standardsâwas a very simple deal. One agent Iâd known for a while insisted that the key was to maximize the advance: âIf the book earns out its advance [i.e. brings in more royalties from actual sales than were paid out up front], I havenât done my job.â But that wasnât my way of doing business. I wanted both sides in any deal to do well.
Then there was the question of which publisher would be the right one. âSell to the highest bidderâ, was the typical advice. But what I cared about was successful book distribution, not how much a publisher might (perhaps foolishly) spend to get the book. Particularly at the time, it was a very clubby but strangely dysfunctional industry, full of belief in a kind of magic touch, but also full of stories of confusion and failure. Still, I thought that access to distribution channels was important enough to be worth navigating this.
And by 1993 quite a bit of time had been spent on discussions about publishing the book. A particular, prominent New York publisher had been identified, and the process of negotiating a contract with them was underway. From a tech industry point of view it all seemed quite Victorian. It started from a printed (as in, on a printing press) 70page contract that seemed to date from 20 years earlier. Though after not very long, essentially every single clause had been crossed out, and replaced by something different.
An effort to âshow what value they could bringâ led to the incident about cover designs mentioned above. And then there was the story about printing, and printing costs. The terms of our potential deal made it quite important to know just how much it would cost to print the book. So to get a sense of that we got quotes from some of our usual printing vendors (and, yes, in those days before the web, a software company like ours did lots of printing). The publisher insisted that our quotes were too highâand that they could print the book much more cheaply. My team was skeptical. But at the center of this discussion was an important technical issue about how the book would actually be printed.
Most widely distributed (“trade”) books are printed on socalled web pressesâwhich are giant industrial machines that take paper from a roll and move it through at perhaps 30 mph. (The term âwebâ here refers to the âweb of paperâ on its path through the machine, not the subsequently invented World Wide Web.) A web press is a good way to print a justreadthewords kind of book. But it doesnât give one much control for pictures; if everythingâs running through at high speed one canât, for example, carefully inject more ink to deal with a big area of black on a specific page.
And so if one wanted to print a more âartqualityâ book one had to use a different approach: a sheetfed press in which each collection of pages is âmanuallyâ set up to be printed separately on a large sheet of paper. Sheetfed presses give one much more controlâbut theyâre more expensive to operate. The printing quotes weâd got were for sheetfed presses, because that was the only way we could see printing the book at the quality level we wanted. (I was sufficiently curious about the whole process that I went to watch a print run for something we were printing. In interacting with our potential publisher, I was rather disappointed to discover that none of the editorial team appeared to have ever actually seen anything being printed.)
But in any case the publisher was claiming that they knew better than us, and that they could get the quality we needed on a web press, at a much lower price. They offered to run a test to prove it. We were again skeptical: to do the setup for a web press is an expensive process, and it makes no sense to do it for anything other than a real print run of thousands of books. But the publisher insisted they could do it. And our only admonition was âDonât show us a result claiming it was made on a web press when it wasnât!â.
A few weeks went by. Back came the test. âYou canât be seriousâ, we said. âThatâs a sheet from a sheetfed press; we can see the characteristic registration marks!â I never quite figured out if they thought they could pull the wool over our eyes, or if this was just pure cluelessness. But for me it was basically the last straw. They came back and said âWhy donât we just refactor the contract and give you a really big advance?â âNopeâ, I said âyouâre profoundly missing the point! Weâre done.â And thatâs howâin 1995âwe came to make the decision to publish A New Kind of Science âourselvesâ.
But when I say âourselvesâ there was quite a bit more to that story. Back at the beginning of 1995 we were thinking about the upcoming third edition of The Mathematica Book, and realizing that we needed to rejigger its publishing arrangements. And while the machinations with publishers about the NKS book had been a huge waste of time, they had helped me understand more about the publishing industryâand made me decide it was time for us to create our own publishing âimprintâ, Wolfram Media.
Its website from 1996 (I never liked that logo!) highlights our first titleâthe copublished third edition of The Mathematica Book:
✕

This was soon joined by other titles, like our heavily illustrated Graphica books. But it wasnât until 1999 that I began to think more seriously about the final publishing of the NKS book. In the fall of 1999 we duly listed the book with the large bookstore chains and book distributors, as well as with the alreadyverysuccessful Amazon. And in late 2000 we started touting the book on our nowmoreattractive website as âA major release coming soon…â:
✕

Particularly in those days, the typical view was that most of the sales of a book would happen in the first few weeks after it was published. Butâas weâll discuss laterâprinting a book (and especially one like the NKS book) takes many weeks. So that creates a tricky situation, in which a publisher has to make a highstakes decision about how many books to print at the beginning. Print too few books and at least for a time, you wonât be able to fill orders, and youâll lose out on the initial sales peak. Print too many books and youâll be left with an inventory of unsold booksâthough the more books you print in a single print run, the more youâll spread the initial setup cost over more books, and the lower the cost of each individual book will be.
Bookstores were also an important part of the picture. Books were at the time still predominantly bought through people physically browsing at bookstores. So the more copies of a book a bookstore had, the more likely it was that someone would see it there, and buy it. And all this added up to a big focus of publishing being on the size of the initial orders that bookstores made.
How was that determined? Mostly it was up to the buyers at bookstores and bookstore chains: they had to understand enough about a book to make an accurate prediction of how many theyâd be able to sell. There was a complicated dance through which publishers signaled their expectations, saying for example âX copy initial print runâ, âXcity promotional tourâ, â$X promotional budgetâ. But in the end it was a very persontoperson sales process, often done by travelingaroundthecountry salespeople whoâd developed relationships with book buyers over the course of many years.
How were we going to handle this? It certainly helped that by late 2000 there were starting to be lengthy news articles anticipating the book. And it also helped that one could see that the book was gaining momentum on Amazon. But would a sales manager we had who was used to selling software be able to sell books? At least in this case the answer was yes, and by the end of 2001 there were starting to be substantial orders from bookstores.
By the time I finished writing the book at the beginning of 2002 we were in full âbookpublishingâ mode. There were still lots of issues to resolve. How would we handle distribution outside the US? (Weâd actually had a UK copublisher lined up but we eventually gave up on them.) How would we reach the full range of independent bookstores? And so on. Looking at my archives I find mail from April 2002 in which I was contacting Jeff Bezos about a practical issue with Amazon; Jeff responded that he âcouldnât wait to read [the book]â, noting that âFor a serious book like yours, we often account for a substantial fraction of sales.â He was rightâand in fact the NKS book would reach the #1 bestseller slot on Amazon.
By the beginning of 2002 weâd had a design for the front cover of the NKS book for six years. But what about the back cover? Itâs traditional to put quotes (âblurbsâ) on the backs of books that people will browse in bookstores. So, in February 2002 we sent a few draft copies of the book to people we thought might give us interesting quotes. Probably the most charming response was Arthur C. Clarkeâs report of the delivery of the book to his house in Sri Lanka:
✕

A few days later, he emailed again âWell, I have <looked> at (almost) every page and am still in a state of shock. Even with computers, I donât see how you could have done itâ, offering the quote âStephenâs magnum opus may be the book of the decade, if not the centuryâ, then adding âEven those who skip the 1200 pages of (extremely lucid) text will find the computergenerated illustrations fascinating. My friend HAL is very sorry he hadnât thought of them first…â
Other quotes came in too. At his request, Iâd sent Steve Jobs a copy of the bookâand I asked if heâd like to provide a quote. He responded that he thought I really shouldnât have quotes on the back of the book. âIsaac Newton didnât have quotes; nor should you.â And, yes, Steve had a point. I was trying to write a book that would have longterm value; it didnât really make sense to have momentofpublication quotes printed on it.
Soâfeeling bad for having solicited quotes in the first placeâwe dropped them from the back cover, instead just putting images from the book that we thought would intrigue people:
✕

Still, my team did use Arthur C. Clarkeâs quote on the publishingindustryobligatory ad we ran in Publisherâs Weekly on April 15 as part of a final sprint to increase upfront orders from bookstores:
✕

At least the way the book trade was in those days, there was a whole arcane dance to be done in publishing a bookâwith carefully orchestrated timing of book reviews, marketing initiatives at bookstores, and so on. My archives contain a whole variety of pieces related to that (many of which I donât think I saw at the time). One of the more curious (whose purpose I donât now know) involves a perhapsnotnaturallycolored lizard that could be viewed as having escaped from page 426 of the book:
✕

From the very beginning I was very committed to doing the best we could in actually printing the book. My original discoveries about rule 30 and its complexity had originally crystallized back in 1984 when I’d first been able to produce a highresolution image of its behavior on a laser printer. Book printing allowed still vastly higher resolution, and I wanted to make use of that to make the NKS book serve if nothing else as a âprinted testamentâ to the idea that complexity can be generated from simple computational rules.
Hereâs what a printout of rule 30 made on a laser printer looks like under a microscope (this printout is from 1999, but it basically looks the same from a typical blackandwhite laser printer today):
✕

And hereâs what the highestresolution picture of rule 30 from the printed NKS book looks like (and, yes, coincidentally that picture occurs on page 30 of the book):
✕

You can see the grain of the paper, but you can also see crisp boundaries around each cell. To give a sense of scale, hereâs a word from the text of the book, shown at the same magnification:
✕

To achieve the kind of crispness we see in the rule 30 picture (while, for example, keeping the book of manageable size and weight) was quite an adventure in printing technology. But the difficulties with pure black and white (as in this picture of rule 30) paled in comparison to those involved with gray scales.
The fundamental technology of printing is quite binary: thereâs either ink at a particular place on a page, or there isnât. But thereâs a standard method for achieving the appearance of gray, which is to use halftoning, based essentially on an array of dots of different sizes. Hereâs an example of that from the photograph of a tiger on page 426 of the NKS book:
✕

But one feature of photographs is that they mostly involve smooth gradations of gray. In the NKS book, however, there are lots of cases where there are tiny cells with different gray levels right next to each other.
Hereâs one example (from page 157âwhich weâll encounter again later):
✕

Hereâs another example with slightly smaller cells (page 640):
✕

Hereâs a nice example based from a 3D graphic (page 180):
✕

And hereâs one where the gray cells are so small that the halftoning gets mixed up with the actual boundaries of cells (page 67):
✕

But in general to achieve welldelineated patches of gray there have to be a decent number of halftone dots inside each patch. And this is one place where we were pushing the boundaries of printing technology for the NKS book. Hereâs an image from a 1995 print test (and, yes, we were testing printing as early as 1992):
✕

This is a more straightforward case, because weâre dealing with exactly 50% gray. But look at the difference for the same picture in the final NKS book:
✕

We slightly changed our standard for how big the mobileautomatonactivecell dots should be. But the main thing to notice is that the halftone checkerboard in each gray cell is roughly twice as fine in the final version. In printing terminology, the 1995 test used a standard â100line screenâ; the final NKS book used a â175line screenâ (i.e. basically 175 dots per inch).
The importance of this is even more obvious when we start looking not just at gray cells, but also at gray lines. Hereâs the 100linescreen print test:
✕

And hereâs the same picture in the final book:
✕

Hereâs the picture that first introduces rule 30:
✕

And a big issue was: how thin can the gray lines be, while not filling in, and while still looking gray? That was a difficult question, and was only answered by lots of print testing. One of the main points was: even if you effectively specify dots of a certain size, what will be the actual sizes of dots formed when the ink is absorbed into the paper? And similarly: will the ink from black cells spread into the area of the gray line youâre trying to print between them? In printing itâs typical to talk about âdot gainâ. If you think youâre setting up dots to give a certain gray level, what will be the actual gray level youâll get when those dots are made of ink on paper?
We were constantly testing things like this, with different printing technology, different paper and so on:
✕

We used a âdensitometerâ (yes, this was before modern digital cameras) to measure the actual gray level, and deduce the dot gain function. And we tested things like how thin lines could be before they wouldnât print.
In halftoning, one effectively applies a global âscreenâ (as in, something with an array of holes in it, just like in predigital printing) to determine the positions of dots. We considered effectively setting up our own dot placement algorithm, that would for example better align with cells in something like a cellular automaton. But tests didnât show particularly good behavior, and we soon reverted to considering the âtraditional approachâ, though with various kinds of tweaking.
Should the halftone dots be round, or elliptical? What should the angle of the array of dots be (it definitely needed to avoid horizontal and vertical directions)? As this manifest indicates, we did many tests:
✕

The final conclusion was: round dots, 175line screen, 45Â° angle. But it took quite a while to get there.
But, OK, so we had a pipeline that started with Wolfram Language code, and eventually generated PostScript. Most of the complexity weâve just been discussing came in converting that PostScript to the image that would actually be printed. And in imaging technology jargon, thatâs achieved by a RIP, or raster image processor, that takes the PostScript and generates a bitmap (normally represented as a TIFF) at an appropriate resolution for whatever will finally render it.
In the 1990s the standard thing to do was first to render the bitmap as a negative onto film. And my archives have tests of this that we did in 1992, here again shown under a microscope:
✕

Everything looks perfectly clean. And indeed printing this purely photographically still gives a perfectly clean result:
✕

But it gets much more complicated when one actually prints this with ink on a printing press:
✕

The basic way the printing is done is to (âlithographicallyâ) etch a printing plate which will then be inked and pressed onto paper to print each copy. Given that one already has film, one can make the plate essentially photographicallyâmore or less the same way microprocessor layouts and many other things are made. But by the beginning of the 2000s, there was a new technology: directtoplate printing, in which an (ultraviolet) laser directly etches the plate (a kind of muchhigherresolution âplate analogâ of what a laser printer does). And in order to get the very crispest results, directtoplate printing was what we used for the NKS book.
Whatâs the actual setup for printing? In the sheetfed approach that we were using, one combines multiple pages (in our case 8) as a âsignatureâ to be printed from a single plate onto a single piece of paper. Hereâs a (yes, ratherunremarkablelooking) actual plate that was used for the first printing of the NKS book:
✕

And hereâs an example of a signature printed from it, with pages that will subsequently be cut and folded:
✕

Under a microscope, the plate looks pretty much like what will finally be printed onto the paper:
✕

But now the next big issue is: what kind of paper should one use? If the paper is glossy, ink wonât spread on it, and itâs easier to get things crisp. But adding a glossy coating to paper makes the paper heavier and thicker, and we quickly determined that it wasnât going to be practical to print the NKS book on glossy paper. Back in the 1980s it had become quite popular to print books on paper that looked good at first, but after a few years would turn yellow and disintegrate. And to avoid that, we knew we needed acidfree paper.
Any particular kind of paper will come in different âweightsâ, or thicknesses. And the thicker the paper is, the more opaque it will be, and the less seethrough the pages of the book will beâbut also the thicker the book will be with a given number of pages. At the beginning we didnât know how long the NKS book would be, and we were looking at comparatively thick papers; by the end we were trying to use paper that was as thin as possible.
Back in 1993 we’d identified Finch Opaque as a possible type of paper. In 1995 our paper rep suggested as an alternative Finch VHF (âVery High Finishâ)âwhich was very smooth, and was quite bright white. But normally this paper was used in very thick pages. Still, it was possible for the paper mill to produce thinner versions as well. We studied the possibilities, and eventually decided that a 50lb version (i.e. with the paper weighing 50 lbs per 500 uncut sheets) would be the best compromise between bulk and opacity. So 50lb Finch VHF paper is what the NKS book is printed on.
Paper, of course, is made from trees. And as Iâll explain below, during the publishing of the NKS book, I became quite aware of the physical location of the trees from which the paper for the NKS book was made: they were in upstate New York (in the Adirondacks). At the time, though, I didnât know more details about the trees. But a few years ago I learned that they were eastern hemlock trees. And it turns out that these coniferous trees are unusual in having long fibersâwhich is what allows the paper to be as smooth as it is. Talking about hemlock makes one think of Socrates. But no, hemlock the poison comes from the “poison hemlock” plant (Conium maculatum), which is unrelated to hemlock trees (which didnât grow in Europe and seem to have gotten their hemlock name only fairly recently, and for rather tenuous reasons). So, no, the NKS book is not poisonous!
Once signatures are printed, the next thing is that the signatures have to be folded and cutâin the end forming little bookletlike objects. And then comes the final step: binding these pieces together into the finished book. By the mid1990s The Mathematica Book had given us quite a bit of experience with the binding of âbig booksââand it wasnât good. Many copies of multiple versions of The Mathematica Book (yes, not printed by us) had basically selfdestructed in the hands of customers.
How were we going to be sure this wouldnât happen for the NKS book? First, many booksâincluding some versions of The Mathematica Bookâwere basically âboundâ by just gluing the signatures into the âcaseâ of the book (with little fake threads added at the ends, for effect). But to robustly bind a big book one really has to actually sew the signatures to the case, and a standard way to do this is whatâs called Smythe sewing. And thatâs what we determined to use for the NKS book.
Still, we wanted to test things. So we sent books to a booktesting lab, where the books were âtumbledâ inside a steel container, 1200 times per hour, âimpacting the tail, binding edge, head and faceâ of each book 4800 times per hour. After 1 hour, the lab reported âspine tight and intactâ. After 2 hours âtext block detached from coverâ. But thatâs basically only after doing the equivalent of dropping the book thousands of times!
As we approached the final printing of the NKS book, there were other decisions to be made. The endpapers were going to have a rule 30 pattern printed on them. But what color should they be? We considered several, picking the goldenrod in the end (and somehow that color now seems to have become the standard for the endpapers of all books I write):
✕

In the late stages of writing the NKS book one of the big concerns was just how long the book would eventually be. Weâd figured out the paper, the binding, and so on. And there was one hard constraint: the binding machines that we were going to use could only bind a book up to a certain thickness. With our specs the limit was 80 signaturesâor 1280 pages. The main text clocked in at 1197 pages; with front matter, etc. that was 1213 pages. But then there was the index. And I was writing a very extensive index, that threatened to overrun our absolute maximum page count. We formatted the index in 4 columns as small and tight as we thought we could. And in the end it came in just under the wire: the book was 1280 pages, with not a single page to spare. (Somewhat simplifying the story, Iâve sometimes said that after a decade of work on the NKS book, I had to stop because otherwise I was going to have a book that was too long to bind!)
Highquality printing of the kind needed for the NKS book was thenâand is nowâoften done in the Far East. But anticipating that we might need to reprint the book fairly quickly we didnât consider that an option; it would just take too long to transport books by boat across the Pacific. And conveniently enough, we determined that there was a costeffective North American alternative: print the book in Canada. And so it was that we chose a printer in Winnipeg, Canada, to print the NKS book.
On February 7, 2002, the files for the book (which were now PDF, not pure PostScript) were transferred (via FTP) to the printerâs computersâa process which took a mere 90 minutes. (Well, it had to be done twice, because of an initial glitch.) But then the next step was to produce âproofsâ for the book. In traditional printing, where printing plates were made from film, one could produce the film first, then make a photographic print of this, check it, and only then make the plates. But we were going to be making plates directly. So for us, âproofingâ was a more digital process, that involved using a separate device from the one that would actually make the plates. Supposedly, though, âthe bits were the bitsâ, and the results would be the same.
Within a couple of days, the printer had the first proofs made, and a few issues were seenâsuch as white labels inside black cells simply disappearing. The cause was subtle, though didnât take a long time to find. Some 3D graphics in the book had generated color PostScriptâand in all our tests so far these had just automatically been converted to grayscale. But now the presence of color primitives had made the RIP that was converting from PostScript change its settingsâand cause other problems. But soon that was worked around, and generating proofs continued.
By February 14 we had the first batch of proofs in our hands, and my team and I went to work going through them. Everything looked just fine untilâughâpage 157:
✕

That was supposed to be a symmetrical (continuous) cellular automaton! So how could it be different on the two sides? Looking now under a microscope, here are the corresponding places on the two sides:
✕

And we can see that somehow on the left an extra column of cells has mysteriously appeared. But where did it come from? We checked the original PostScript. Nope, it wasnât there. We asked the printer to rerun the proof, and, second time around, it was gone. Very mysterious. But we figured we could go aheadâand in any case we had a tight schedule to meet.
So on February 17 the book designer whoâd worked on the project ever since the beginning went to Winnipeg, and on February 18 the book began to be printed.
I wasnât there (and actually now I wish Iâd gone) but a bunch of pictures were taken. After a decade of work all those abstract bits Iâd produced were being turned into an actual, physical book. And that took actual industrial work, with actual industrial machines:
✕

Hereâs the actual press thatâs about to print a signature of the NKS book (the four âstationsâ here are set up to print four different colors, but we were only using one of them):
✕

And hereâs that signature âcoming off the pressâ:
✕

It really was coming out âhot off the pressââwith a machine drying off the ink:
✕

Those controls let one change ink flows and pressures to make all the pages come out correctly balanced:
✕

Thanks, guys, for checking so carefully:
✕

✕

Pretty soon there were starting to be lots of copies of signatures being printed:
✕

Andâafter being involved for more than a decadeâthe book designer was finally able to sign off on the printed version of the opening signature of the book:
✕

The whole process of printing all the signatures of the book was scheduled to take about four weeks. We had been receiving and checking the signatures as they were readyâand on March 12 we received the final batch, and began to check them, on the alert for any possible repeat of something like the page157 problem.
Within a few hours a member of our team got to page 332 (on âsignature 21â) which included this image:
✕

Iâm frankly amazed he noticed, but if you look carefully near the righthand edge you might be able to tell that thereâs a strange kind of âseamâ. Zoom in at the top and youâll see:
✕

And, yes, this is definitely wrong: with the aggregation rule used to make this picture it simply isnât possible to have floating pieces. In this case, the correct version is:
✕

An hour or so later two more glitches were found, on page 251 and 253. Both cases again involved something like a column of cells being repeated. On page 253 zooming into the image
✕

reveals strange and âimpossibleâ imperfections in the supposedly periodic background of rule 110:
✕

On page 194 there was another glitch: an arrow on a graph that had basically become too thin to see. But this problem at least we could understandâand it was our fault. Instead of setting the thickness of the arrow in some absolute way, weâd just set it to be â1 pixelââwhich in the final printing was too thin to see.
But what about the other glitches? What were they? And might there be more of them?
The signatures from the book were ready to start being bound. Should we hold off and reprint the signatures where weâd found glitches? Could we do this without blowing our (already very tight) schedule? Could we even get enough extra paper in time? My team was adamant that we should try to fix the glitches, saying that otherwise they would ânag at us foreverâ. But I wanted first to see if we could characterize the bug better.
We knew it was associated with the rendering of the PostScript image operator. Even though PostScript is basically a vector graphics description language, the image operator allows one to include bitmaps. Normally these bitmaps are used to represent things like photographs, and have tiny (âfewpixelâ) cells. But in the cellularautomatonlike images we were having trouble with, the cells were much larger; in the case of page 157, for example, each one was roughly 75 of the final 2400dpi pixels across. This was absolutely something the image operator was set up to handle. But somehow something was going wrong.
And what was particularly surprising is that it seemed as if the problem was happening after the PostScript was converted to a TIFF. Could it perhaps be in the driver for both the proofing and the final plate production system? Time was short, and we needed to make a decision about what to do.
I fired off an email to the CEO of the company that made the directtoplate system, saying: “We of course do not know the details of your software and hardware systems. However, we have done a little investigation. It appears that the data … in the case of this image is a bilevel TIFF with LZW compression. We speculate that the LZW dictionary contains something close to the actual squares seen in the image, and that somehow pointers to dictionary entries are being corrupted or are not being used correctly in the decompression of the TIFF. The TIFF experts at my company say they have never seen anything like this in developing software based on standard imaging libraries, making us suspect that it may be some kind of buffering or motion optimization bug associated with your actual hardware driver.”
The CEO of what was by then quite a large company had personally designed the original hardware, and when we talked by phone he speculated that what we were seeing might be some kind of obscure mechanical issue with the hardware. But his chief of software soon sent mail explaining that âof the several hundred thousand books that go through [their system] each year, there are a couple that have imaging problems like this.â But, he added, âUsually they are books about halftone screening algorithms, which cause an almostrecursive problem…â. He said the specific issue we were having looked like a âdifficult to reproduce problem we have known about for some time but is transient enough that reimaging the same file can âcorrectâ the problem.â He added that: âOur hypothesis is that it is related to a memory access error in the RIP that manifests only at lowmemory conditions, or after many allocation/deallocation cycles of RAM blocks. The particular code path is not one we have sourcecode access to, and is rumored to be many years old, so not many people on earth are prepared to make substantive changes to it.â
OK, so what next? The RIP had been developed by Adobe, creators of PostScript. So I emailed John Warnock, cofounder of Adobe, who Iâd met at quite a few softwareindustry gettogethers before my NKSbook âhermit periodâ. I commented that âOne thing thatâs peculiar (at least without knowing how the RIP works) is that the glitch involves overwriting of a column … even though scanning the underlying PostScript would involve going from one row to the next.â Warnock responded helpfully, copying his team, though saying (in an echo of what weâd already heard) âI donât know who does PostScript stuff anymoreâ.
Well, that seemed like pretty much the end of the road. So we decided to assume that the glitches weâd found were the only ones, andâfor perfectionâs sakeâweâd reprint those signatures, which by that point the printer had helpfully said they could do without blowing the schedule.
Two weeks later, Adobe delivered a new version of the RIP, in which they believed the bug had been fixed, noting that there had been significant code cleanup, and they were now using a newer version of the C++ compiler. Meanwhile, Iâd realized another issue: a variety of magazines had requested files from us to be able to print highresolution images from the book. Would they end up using the same software pipeline, and potentially have the same problem? A general release of any fix was still quite far away.
Meanwhile, with the two âglitchâ signatures reprinted, the book was off to be bound. The cover had also been printed, now making use of all four stations of the presses. Under a microscope the characteristic “rosettes” of 4color printing are visible:
✕

Actually, the book in a sense has two covers: a detachable dust jacket (including a dated picture of me!) and a âpermanentâ hard coverâwhich I think looks very nice:
But as I was just now looking back through my archives I found an email from February 2002, expressing concerns about the fading of ink on the cover. The printer assured us that we had ânothing to worry about unless the books were exposed to direct sunlight for an extended amount of time.â But then they added âThe reds and yellows will fade faster that the other pigments, but this is not something that would be noticeable in the first 20â40 years.â Well, itâs now been 20 years, and it so happens that I have a copy of the NKS book thatâs been exposed to sunlight for much of that timeâand look whatâs happened to its spine, right on cue:
✕

I received a first, handbound, finished NKS book on April 22. And very soon books were on their way to bookstores and distribution centers. And people were ordering the bookâin large numbers. And that meant that the books weâd printed so far werenât going to be enough. And on May 12âtwo days before the May 14 official publication date of the bookâanother print run was started.
Fortunately it was possible to reuse the plates from the first print run (well, apart from the one which said âFirst printingâ), so we didnât have to worry about new glitches showing up.
But once the book was published, demand continued to be strong, and on June 4 we needed to do another print run. And this time new plates had to be made. Were there going to be new glitches? We decided we should check the plates before we started printingâso we sent the person whoâd caught the glitches before on a trip to Canada. Turns out the bug hadnât yet been fixed, and there it was again on pages 583 and 979.
Some time later I heard that the bug was finally found and fixed, and had been lurking in the implementation of the PostScript image operator for well over a decade. Yes, software is hard. And computational irreducibility is rampant. But in the years since the NKS book was published, no other weird glitches like this have ever shown up. Or at least nobody has ever told us about any.
But as I was writing this, I wondered: what became of that other glitch that was in the first printingâthe one with the thin arrows that was our fault? I opened an NKS book from my desk. No problem. But then I pulled off my shelf the leatherbound copy of the first printing that my team made for me, and turned to page 194. And there it wasâthe â1pixel arrowâ (compared here under a microscope to the second printing):
✕

And yet one more thing: looking in my archives, I find a cover sheet for a print test from March 1, 1999âwhich notes that there is âglitch with the graphic on page 246â … âwhich has been traced to a problem with the Adobe 4.1 PostScript driverâ for the RIPâmade by a completely different company:
✕

Was it the same âpage157â bug? I looked for the print test. And thereâs âpage 246â (which ended up in the final version as page 212):
✕

Under a microscope, most of the arrays of cells look just fine:
✕

But there it is: something weird again!
✕

Is it the same âpage157â bug? Or is it another bug, perhaps even still there, 23 years later?
When the NKS book was officially published on May 14, 2002, it was the #1 bestselling book on Amazon, and it was steadily climbing the New York Times and other bestseller lists. Weâd just initiated a second printing, which would be finished in a few weeks. But based on apparent demand that printing wasnât going to be sufficient. And in fact a single bookstore chain had just offered to buy the whole second printing. We initiated a third printing on June 4, and then a fourth on June 18. But if we were going to keep the momentum of sales, we knew we had to keep feeding books into the channel.
But that’s where things got difficult again. It just didn’t seem possible to get enough books, quickly enough. But after everything weâd done to this point, I wasnât going to be stopped here. And I went into full âhandson CEOâ mode, trying to see how to juggle logistics to make things work.
The paper mill was in Glens Falls, NY. Once the paper had been made, it had to be trucked 2752 km to the printer in Winnipeg, Canada. Then the finished âbook blocksâ had to go 2225 km to the bindery in Toronto (or maybe there was an alternative bindery in Portland, OR, 2400 km away). And finally the bound books had to come to our warehouse in Illinois, or go directly to book distribution centers.
My archives contain a diagram I made trying to see how to connect these things together, particularly in view of the impending Canada Day holiday on July 1:
✕

I have pages and pages of notes, with details of ink drying times (1 day), sheets of paper per skid (20,000), people needed per shift, and so on. But in the end we made it; with a lot of peopleâs help, we got the books finished on timeâand put on trucks, some of which were going to the distribution center for a major bookstore chain.
The trucks arrived. But then we heard nothing. Bookstores were reporting being out of stock. What was going on? At last it was figured out: multiple truckloads of books had somehow been misplaced at the distribution center. (How do you lose something that big?) And, yes, some sales momentum was lost. And so we didnât peak as high on bestseller lists as we might. Though hopefully in the end everyone who wanted an NKS book got one, no doubt oblivious to the logistical challenges involved in getting it to them.
For more than a decade I basically poured everything I was doing into the NKS book. Well, at least thatâs the way I remember it. But going through my archives now, I realize I did quite a bit that never made it into the final NKS book. Particularly from the early years of the project, there are endless photographsâand investigationsâof examples of complexity in nature, which never made it into Chapter 8. There are also lots of additional results about specific systems from the computational universeâas well as lots of details about historyâthat could have been notes to the notes, except I didnât have those.
Something I didnât remember is that in 1999âas the book was nearing completionâI considered adding a pictorial âQuick Summaryâ at the front of the book, here in draft form:
✕

Iâm not sure if this would have been a good idea, but in the end it effectively got replaced by the textual âAn Outline of Basic Ideasâ that appears at the very beginning of the book. Still, right when the book was being published, I did produce an âoutside the bookâ pictorial 1pager about Chapter 2 that saw quite a bit of use, especially for media briefings:
✕

But as I was looking through my archives, my biggest ârediscoveryâ is the âEpilogâ to the book. There are versions of it from quite early in the development of the book, but the last time it appears is in the December 15, 2000, draftâright before âAlpha 1â. Then itâs gone. Well, that is, until I just found it again:
✕

So whatâs in this âlost epilogâ, with its intriguing title âThe Future of the Science in This Bookâ? Different versions of it contain somewhat different fragmentary pieces of text. The version from late 1999, for example, begins:
✕

Later it continues (the bracketed text gives alternative phrasings I was considering):
✕

Some of what was in the âlost epilogâ found its way into the Preface for the final book; some into a âGeneral Noteâ entitled âDeveloping the new kind of scienceâ. But quite a lot never made it. Itâs often quite roughhewn textâand almost just ânotes to myselfâ. But in a section entitled âWhat Should Be Done Nowâ, there are, for example, suggestions like:
✕

And thereâs a list of âprinciplesâ that arenât a bad summary of at least my general approach to research:
✕

Later on there are some rough notes about what I thought might happen in the future:
✕

Itâs a charming timecapsulelike item. But itâs interesting to see how what I jotted down more than 20 years ago has actually panned out. And in fact I think much of it is surprisingly close to the mark. Plenty of small extensions did indeed get made in the first few years, with larger onesâboth in studying abstract systems and in building practical modelsâcoming later. (One notable extension was the 2,3 Turing machine universality proof at year 5, stimulated by our 2,3 Turing Machine Prize.)
How about âmajor new directionsâ? Weâre remarkably âon cueâ there. At year 18 was our Physics Project, and from that has emerged the whole multicomputational paradigm, which I consider to be the next major direction building on the ideas of the NKS book. I have to say that when I wrote down these expectations 20+ years ago, I didnât imagine that I would personally be involved in the âmajor new directionâ I mentionedâbut, unexpected as it has been, I feel very fortunate that thatâs the way itâs worked out.
What about technology? Already at year 7 WolframAlpha was in many ways a major “philosophical spinoff” of the NKS book. And although one doesnât know its detailed origins, the proofofwork concept of bitcoin (which also first appeared at year 7) has fundamental connections to the idea of computational irreducibility. Meanwhile, the general methodology of searching the computational universe for useful programs is something that has continued to grow. And although the details are more complicated, the whole notion of deep learning in neural nets can also be thought of as related.
Itâs very hard to assess just whatâs happened in âbecoming a part of everyday thoughtââthough itâs been wonderful over the years to run into so many people whoâve told me how much the NKS book affected their way of thinking about things. But my impression is thatâdespite quite a few specific applicationsâthe truly widespread absorption of ideas like computational irreducibility and their implications is a bit âbehind scheduleâ, though definitely now building well. (One piece of absorption that did happen in the 4â10 year window was into areas like art and architecture.)
What about education? 1D cellular automata have certainly become widely used as âdoalittleextraâ examples for both programming and math. But more serious integration of ideas from the NKS book as foundational elements of computational thinkingâor as a kind of âprecomputer scienceââis basically still a âwork in progressâ.
Beyond the main text of the âlost epilogâ, I found something else: âNotes for the Epilogâ:
✕

And after short (and unfinished) notes on âThe sociology of the new scienceâ and âThe role of amateursâ, thereâs the most significant âfindâ: a list of altogether 283 âOpen questionsâ for each of the chapters of the book, most still unanswered.
In preparation for our first Wolfram Summer School (then called the NKS Summer School) in June 2003, I worked on a more detailed version of something similarâbut left it incomplete after getting up to the middle of Chapter 4, and didnât include much if anything from the âNotes to the Epilogâ even though Iâd been accumulating those for much of the time I worked on the book:
✕

During the decade I worked on the NKS book I generated a vast amount of material. Most of it I kept in my stillverymuchextant computer filesystem, and while I canât say that Iâve reexamined everything there, my impression is thatâperhaps apart from some ânotes to the notesâ materialâa large fraction of what should have made it into the NKS book did. But in the course of working on the book there was definitely quite a bit of more ephemeral material. Some was preserved in my computer filesystem. But some was printed out and discarded, and some was simply handwritten. But all these years Iâve kept archive boxes of that material.
Some of those boxes have now been sealed for nearly 30 years. But I thought itâd be interesting to see what they contain. So I pulled out a box labeled 6/93â10/93. Itâs slightly the worse for wear after all these years, but whatâs inside is well preserved. I turn over a few pages of notes, printouts and ancient company memos (some sent as faxes). And then: whatâs this?
✕

Itâs a note about multiway systems: things that are now central to the multicomputational paradigm Iâve just been pursuing. Thereâs a brief comment about numerical multiway systems in the NKS bookâbut just last year, I wrote a whole 85page “treatise” about them.
I turn over a few more pages. It feels a bit like a time warp. I just wrote about multiway Turing machines last year, and my very recent work on metamathematics is full of multiway string rewrites and their correspondence to mathematical proofs!
✕

A few more pages and I get to:
✕

Itâs not something that made it into the NKS book in that formâbut last year I wrote a piece entitled âHow Inevitable Is the Concept of Numbers?â which explores (in an admittedly modernized way) some of the exact same issues.
A few more pages later I get to âtimelessâ graphics like these:
✕

But soon thereâs a charming reminder of the times:
✕

Iâve only gone through perhaps an inch of paper so far. And Iâm getting to pages like these:
✕

Yes, Iâm still today investigating consequences of âcomputational irreducibility and the PCE (Principle of Computational Equivalence)â. And just last year I used as a central example in writing about numerical multiway systems!
Iâve gone through perhaps 10% of one boxâand there are more than 40 boxes in all. And I canât help but wonder what gems there may be in all these âouttakesâ from the NKS book. But Iâm also thankful that back when I was working on the NKS book I didnât try to pursue them allâor the decade I spent on the book might have stretched into more than a lifetime.
On May 14, 2002, the NKS book was finally published. In some ways the actual day of publication was quite anticlimactic. In modern times thereâd be that moment of âmaking things liveâ (as there was, for example, for WolframAlpha in 2009). But back then thereâd been a big rush to get books to bookstores, but on the actual âday of publicationâ there wasnât much for me to do.
It had been a long journey getting to this point, though, and for example the acknowledgements at the front of the book listed 376 people whoâd helped in one way or another over the decade devoted to writing the book, or in the years beforehand. But in terms of the physical production of the book one clue about what had been involved could be found on the very last pageâits âColophon”:
✕

And, yes, as Iâve explained here, there was quite a story behind the simple paragraph: âThe book was printed on 50pound Finch VHF paper on a sheetfed press. It was imaged directly to plates at 2400 dpi, with halftones rendered using a 175line screen with round dots angled at 45Â°. The binding was Smythe sewn.â And whatever other awards the book would win, it was rather lovely to win one for its creative use of paper:
✕

So much about the NKS book was unusual. It was a book about new discoveries on the frontiers of science written for anyone to read. It was a book full of algorithmic pictures like none seen before. It was a book about science produced to a level of quality probably never equaled except by books about art. And it was a book that was published in a direct, entrepreneurial way without the intermediation of a standard large publishing company.
Publisherâs Weekly ran an interestingâand charmingly titledâpiece purely about the âpublishing dynamicsâ of the book:
Just before the book was finally published, Iâd signed some copies for friends, employees and people whoâd contributed in one way or another to the book:
✕

Shortly after the book was published, we decided to make a âcommemorative posterâ, reproducing (small, but faithfully) every one of the pages that had taken so much effort to create:
✕

Then there were the âcomputationalirreducibilityinspiredâ bookmarks that I, for one, still use all the time:
✕

We carefully stored a virtual machine image of the environment used to produce the book (and, yes, thatâs how quite a few of the images here were made):
✕

And over the years that followed weâd end up using the raw material for the book many times. Within a year there was âNKS Explorerââa Wolfram Notebook system, distributed on CDROM, that served as a kind of virtual lab that let one (as it put it) âExperience the discoveries of A New Kind of Science on your own computerâ:
✕

About five years later, more or less the same content would show up in the webaccessible Wolfram Demonstrations Project (and 10 years later, in its cloud version):
✕

When the book came out, there was already a âwolframscience.comâ website:
✕

But in 2004 we were able to put a full version of the NKS book on the web:
✕

In 2010 we made a version for the iPad:
✕

And in recent years there have followed all sorts of modernizations, especially on the webâwith a bunch of new functionality just recently released:
✕

I went to great effort to write the NKS book to last, and I think itâs fair to sayâ20 years outâthat it very much has. The computational universe, of course, will be the same forever. And those pictures of the behavior of simple computational systems that occur throughout the book share the kind of fundamental timelessness that pictures of geometric constructions from antiquity do.
Of course, I knew that some things in the book would “date”, most notably my references to technologyâas I warned in one of the “General Notes” at the back of the book (though actually, 20 years later, notwithstanding âelectronic address booksâ from page 643, and MP3 on page 1080 being described as a ârecentâ format, surprisingly little has yet changed):
✕

What about mistakes? For 20 years weâve meticulously tracked them. And I think itâs fair to say that all the careful checking we did originally really paid off, because in all the text and pictures in the book remarkably few errors have been found. For example, hereâs the list of everything in Chapter 4, indicating a few errors that were fixed in early printingsâand a couple that remain, and that we are now fixing online:
People ask me if thereâll be a second edition of the NKS book. I say no. Yes, there are gradually starting to be more things one can sayâand in the past couple of years the Wolfram Physics Project and the whole multicomputational paradigm has added significantly more. But thereâs nothing wrong with whatâs in the NKS book. It remains as valid and coherent as it was 20 years ago. And any âsecondedition surgeryâ would run the risk of degrading its crispness and integrityâand detract from its unique perspective of presenting science at the time of its discovery.
But, OK, so all those NKS books that were printed on all those tons of paper from hemlock trees 20 years ago: what happened to them? Looking on the web today, one can find a few out there in the wild, sitting on bookshelves alongside a remarkable variety of other books:
I myself have many NKS books on my shelves (though admittedly a few more as convenient 2.5inch âfiller bookendsâ). Andâat least when Iâm in a âscience phaseââI find myself using the online NKS book (if not a physical book) all the time, to see an example of some remarkable phenomenon in the computational universe, or to remind myself of some elaborate explanation or result that I put so much effort into finding all those years ago.
I consider the NKS book one the great achievements of my lifeâas well as one of the great âsteppingstoneâ points in my life, that was made possible by what Iâd done before, and that in turn has made possible what Iâve done since. Twenty years later itâs interesting to think backâas Iâve done hereâon just what it took to produce the NKS book, and how all those individual steps that I worked so hard on for a decade came together to make the whole that is the NKS book.
To me itâs a satisfying and inspiring story of what can be achieved with clear vision, sustained effort and a willingness to go where discoveries lead. And as I reflect on achievements of the past it makes me all the more enthusiastic about whatâs now possibleâand why itâs worth putting great effort today into what we can now build for the future.
]]>Something remarkable has happened these past two years. For 45 years Iâve devoted myself to building a taller and taller tower of science and technologyâwhich along the way has delivered many outputs of which Iâm quite proud. But starting in 2020 with the unexpected breakthroughs of our Wolfram Physics Project weâve jumped to a whole new level. And suddenlyâyes, building on our multidecade towerâit seems as if weâve found a new paradigm thatâs incredibly powerful, and thatâs going to let us tackle an almost absurd range of longstanding questions in all sorts of areas of science.
Developing a fundamental theory of physics is certainly an ambitious place to start, and Iâm happy to say that things seem to be going quite excellently there, not least in providing new foundations for many existing results and initiatives in physics. But the amazing (and to me very unexpected) thing is that we can take our new paradigm and also apply it to a huge range of other areas. Just a couple of weeks ago I published a 250page treatise about its application to the âphysicalization of metamathematicsââand to providing a very new view of the foundations of mathematics (with implications both for the question of what mathematics really is, and for the practical longterm future of mathematics).
In a sense, everything weâre doing ultimately builds on the great intellectual tide of the past century: the rise of the concept of computation. (And, yes, thatâs something in which Iâve been deeply involved both scientifically and technologically throughout my career.) But whatâs happening now is something elseâthat one can see as the birth of what I call the multicomputational paradigm. Itâs all about doing what our Physics Project has suggested, and going beyond working with specific computationsâto look at the systemic behavior of whole interacting collections of computations. In the whole multimillennium history of science, thereâve only been a very few fundamentally different paradigms for making models of thingsâand I think multicomputation is basically the fourth one ever.
And what makes its arrival particularly dramatic is that it comes already supercharged by its deep relation to physics, and by its ability to spread the successes of physics to other areas of science, and beyond. When I started investigating the concept of computational irreducibility in the 1980s it became clear that there are fundamental barriers to many kinds of scientific progress. But what I didnât see coming is there would be a new path opened up by a new paradigm: the paradigm of multicomputation. And suddenly there are now all sorts of fundamental questions that are no longer blockedâand instead are ripe for rapid progress.
Over the past year weâve started exploring a host of potential application areas. Weâve got a concept of âformalized subchemistryâ with applications to a new way of thinking about molecular computing, and with potentially dramatic implications for molecular biology. Weâve got new ideas about how to think about immunology and probably also neuroscience. Weâve got a potential new approach to finding a formalization for biological evolution and its relation to biocomplexity. Weâve got a new concept for âgeometrizingâ the space of programsâwith implications for foundational questions in computational complexity theory. Weâve got a promising way to construct new kinds of theories for economics, with implications, for example, for distributed generalizations of blockchain. Weâve got a potential new way to think about linguistics, and the structure of meaning space. Oh, and weâve got a new âphysicalizedâ way to conceptualize and organize distributed computing.
In the nearly half a century that Iâve been doing science, Iâve had the good fortune to be involved in quite a few significant bursts of progress. But Iâve never seen one quite as concentrated and immediate as what weâre now seeing. Itâs an exciting thing. But itâs also overwhelming. Thereâs just so much lowhanging fruit to be pickedâso many things with such important potential consequences, for science, technology and the world.
Weâve been working very hard to move all this forward with the resources we have available. But even though I think weâve achieved a remarkable level of productivity, itâs become clear that thereâs just too much to do. Weâre in the midst of a major âscience opportunity overloadâ. And to be good stewards of the ideas and their potential weâve got to scale things up. Iâve had lots of experience over decades in making big projects happen. And now itâs time to take that experience and define a new structure to move forward the amazing science opportunity we find ourselves with.
And I think that leaves us no choice: weâve got to launch the Wolfram Institute, and now!
In the course of my life Iâve spent a great deal of effort trying to maximize productivity and innovation around the things I do. Iâve done lots of (arguably nerdy) optimization of my own personal setup. Iâve thought long and hard about the best strategies both for choosing what to do, and for getting things done. But in many ways the most important piece has been the whole structure weâve built up over the past 35 years at Wolfram Research.
I sometimes refer to our company as a machine for turning ideas into real things. And I think itâs been an extremely impressive machineâyear after year for more than three decades systematically delivering all sorts of farreaching innovation, and using our progressive tower of technology to efficiently implement it on larger and larger scales.
As a company, weâve mainly been concerned with delivering technology and products. But the systems, culture and methodologies weâve developed are, at their core, about maximizing innovation and productivity. So what happens if we apply them to science?
A New Kind of Science was in a sense a first result, and I consider it an impressive one. Indeed, even nearly 20 years after it was published Iâm still amazed at the sheer volumeâand depthâof scientific results that it was possible to obtain in the span of just a single decade.
But with the Wolfram Physics Project itâs a yet more impressive story. We started late in 2019, and in less than six monthsâwith an extremely small teamâwe were able to make dramatic progress, and to publish nearly 700 pages of material about it. It wouldnât have been even vaguely possible without the whole tower of computational tooling provided by the Wolfram Language. And nor would it have been possible without the structure and strategy for doing projects that weâve honed over the past three decades.
In the past two years, weâve been energetically moving forwardâand weâve now published altogether over 2500 pages of new material, as well as nearly 200 publicly deployed new functions. In terms of scientific ideas the pace of innovation has been quite breathtaking. But weâve also been innovating in terms of how to do the science.
An important objective has been to open the science up to give the widest possible access and potential for engagement. Iâve worked hard to define a style of expository writing that makes what weâve done accessible to a wide audience as well as to experts. And in what we’ve published, essentially every graphic has “clicktocopy” Wolfram Language code, that anyone can immediately run and build on. We’ve also uploaded our working notebooksâso far nearly 2000 of themâso that everyone can see not only our âfinished productâ but also the research (wrong turns and all) that led to it.
A few years ago I started livestreaming to the world many of our software design reviews. And building on this concept, weâve now routinely been livestreaming our scientific working sessionsâgiving people for the first time realtime visibility into how science is done, as well as the possibility to interact with it. And for those interested in an even deeper dive, weâve also been recording and uploading âvideo work logsââbringing us up to a total of nearly 1000 hours of video so far.
Even when we thought we were âjust solving physicsâ we knew we had to involve other people in the project. For 20 years weâve been doing a very successful annual Summer School about our approach to science and technology, and starting in 2020 we added a track about the Physics Project, as well as a physics Winter School. Weâve had a terrific stream of âstudentsâ for our Physics Project. And partly building on this weâve been setting up a network of people involved in the Physics Projectânow with 55 members from 20 countries.
Increasingly, thereâs work based on our Physics Project thatâs happening in academic institutions, quite independent of us. And no doubt this will bear all sorts of fruit.
But as we look at the next phases of our Physics Project, and even more so the huge collection of opportunities provided by our new multicomputational paradigm, itâs clear thereâs so much to do thatâparticularly if we want it to happen in years rather than decadesâwe need a more focused approach.
And the good news is that through 35 years of experience at Wolfram Research, as well as the experience of A New Kind of Science and the Wolfram Physics Project, we have an excellent blueprint for what to do. But now we have to implement it at scale. And thatâs what the Wolfram Institute is about.
The basic plan is simple: to create a basicscience analog of the immensely productive âmachineâ that Iâve built at Wolfram Research over the past 35 yearsâand to use this âmachineâ to accelerate the delivery of new science by many decades if not more. Weâve already got a definite seed: the Wolfram Physics Project. But now we have to scale this up to the full Wolfram Instituteâand give it the structure it needs to grow and take full advantage of the amazing opportunities we now have.
Itâs often assumed that the way to achieve maximum innovation is to put together innovative people, and then let them âjust innovateâ in whatever directions they choose. But it has been my consistent experience that the greatest innovation is instead achieved when there is a definite âflowâ and definite, ambitious goals. The Wolfram Institute is going to be about doing largescale basic research this way.
Modeled on Wolfram Research and the Wolfram Physics Project, the idea of the Wolfram Institute is to aggressively pursue basic research thatâs explicitly managed and energetically led towards its goals.
Our initial goals are already tremendously ambitious. We want to use our new paradigm to basically rewrite the foundations of several important fields of science. As with the Physics Project thereâll no doubt be tremendous synergy with existing approaches and the communities around them. But with the paradigm we now have, the tools and methods weâve developed, and the organizational framework weâre defining for the Wolfram Institute, I think we have the opportunity to jump ahead, and in effect to deliver foundational science that would otherwise emerge at best only in the distant future.
Itâs going to be an exciting thing to be a part of, andâas with projects Iâve done in the pastâthere are going to be many outstanding people who want to be involved. Our many decades of activity in science and technology have provided an extremely broad network of contacts, and weâve developed a particularly concentrated pipeline of worldwide talent through our annual Summer School (as well as our High School Summer Camp).
What will the Wolfram Institute be like? Thereâll be a leadership core, which, yes, Iâm signing up to head. But the main meat of the institute will be a collection of researchers and fellows, working on particular, managed projectsâtogether with students at multiple levels from high school to graduate school. Weâll be doing open science, so thereâll be lots of livestreaming and lots of open tools produced. Thereâll be lots of working materials and academic papers published, and whenever we manage to make a big step forward our plan is to present it to the world using the immediate and accessible approach to exposition that Iâve developed.
In what weâve done for the past 35 years at Wolfram Research thereâs in a sense a clear model for how the organization fundamentally operates. We invent things, then we deliver them in productsâand from these products we derive revenue, which is then used to allow us to invent more things and deliver more products. Itâs been an extremely productive setup. And because weâre a private company without outside investment weâre able to chart our own course, pursuing the ambitious and longterm projects that we believe in. Often we choose to make things we do freely available to the world, but in the end we rely on the fact that weâre producing commercially valuable products from which we derive revenue that funds our activities.
Thereâs no question that the science weâll be doing at the Wolfram Institute will lead to things of great value to the world. But it wonât be nearterm commercial value. And our fundamental model is to concentrate on producing the best and broadest longterm basic researchârather than to aim for things that can be deployed directly in specific products that provide immediate value to specific customers.
In a sense, our âcustomerâ is the world at largeâand the future. But in the present we need a way to support our researchers and fellows. So far weâve basically been incubating the Wolfram Institute within our existing organization, with me effectively footing the bill. But as we launch the full Wolfram Institute we need a larger scale of support, and weâre counting on having a network of people and organizations to provide that.
Some of the support will be for specific researchers, fellows or students, perhaps drawn from particular geographies, backgrounds or communities. Some of it will be for specific projects. But itâs also important to have a stable core of support that will allow the institute to pursue longterm basic research that will likely deliver many of its most valuable results through developments that are in effect computationally irreducible to predict in advance.
Itâs difficult to know how society at large should value the general activity of basic research, and itâs easy to criticize the inefficiencies of a largescale âjust let researchers do what they wantâ approach. But with the Wolfram Institute we have a very different model. Weâre starting the institute right now for a specific reason: weâve got a new paradigm thatâs just opened up an amazing collection of possibilities. And we plan to pursue those possibilities in an efficient and tightly managed way, optimized for innovation and new ideas.
When I look at our Physics Project and what weâve achieved so far with it, Iâm frankly amazed at how quickly and comparatively frugally weâve managed to do it. (Yes, it helps that at least so far we need only people and computers, not telescopes and particle accelerators.) And as we scale this up to all the various projects we plan at the Wolfram Institute, itâs almost absurd how much of longterm significance I expect we will be able to deliver for how comparatively little.
The Wolfram Physics Project has been done as an entirely geodistributed projectâbuilding on the 30+ years of experience with coherent geodistributed work that weâve had at Wolfram Research. And even though its projects will be tightly managed, the Wolfram Institute will also primarily be geodistributed, although we plan regular physical events and weâll probably have some physical locations available.
Itâs been great in working on the Wolfram Physics Project to have what weâve been doing be so open, and to be able to share it with so many people. And as we launch the Wolfram Institute Iâm looking forward to having all sorts of people involved, both within the institute, and as supporters of it.
Itâs been exciting these past many months seeing the whole multicomputational paradigm emerge, and seeing more and more possibilities reveal themselves. Itâs a remarkableâif overwhelmingâcollection of opportunities, and I believe a historic moment for the progress of science. And as we launch the Wolfram Institute I hope that with the help of enough supporters weâll be able to deliver many dramatic results that will have great longterm value to the world and to the arc of intellectual history.
It seems like the kind of question that might have been hotly debated by ancient philosophers, but would have been settled long ago: how is it that things can move? And indeed with the view of physical space thatâs been almost universally adopted for the past two thousand years itâs basically a nonquestion. As crystallized by the likes of Euclid itâs been assumed that space is ultimately just a kind of âgeometrical backgroundâ into which any physical thing can be putâand then moved around.
But in our Physics Project weâve developed a fundamentally different view of spaceâin which space is not just a background, but has its own elaborate composition and structure. And in fact, we posit that space is in a sense everything that exists, and that all âthingsâ are ultimately just features of the structure of space. We imagine that at the lowest level, space consists of large numbers of abstract âatoms of spaceâ connected in a hypergraph thatâs continually getting updated according to definite rules and thatâs a huge version of something like this:
✕

But with this setup, what even is motion? Itâs no longer something baked into our basic ideas about space. Insteadâmuch like the ancient philosophers imaginedâitâs something we can try to derive from a lower level of description. Itâs not something we can take for grantedâand indeed itâs going to turn out that its character depends in fundamental ways on issues like our nature as observers.
To have a concept of motion, one has to have not only a concept of spaceâand timeâbut also a concept of âthingsâ. One has to have something definite that one can imagine moves through space with time. And in effect the concept of âpure motionâ is that there can be a âthingâ that âjust movesâ without âchanging its characterâ. But if the thing is âmade of atoms of spaceâ that are continually getting updated, what does this mean? Somehow the identity of the âthingâ has to be associated with some collective characteristic that doesnât depend on the particular atoms of space from which itâs made.
Thereâs an immediate analogy here. Consider something like a vortex in a fluid. The vortex can move around as a âthingâ even though âunderneathâ itâs made of an everchanging collection of lots of discrete molecules. If we looked in microscopic detail, weâd see effects from those discrete molecules. But at the scale at which we humans typically operate, we just consider there to be a definite âthingâ we describe as a vortexâthat at this level of description exhibits âpure motionâ.
Our fundamental model of space is not so different from this. At the lowest level thereâs continual activity associated with the application of rules that create new atoms of space and new connections between them. And just as continual collisions between molecules in a fluid âknit togetherâ the structure of the fluid, so also the continual rewriting of the hypergraph that connects atoms of space knits together the structure of space. But then on top of this there can be âlocalized collective featuresâ that have a certain persistence. And these are the âthingsâ (or âobjectsâ) that we can consider to âshow pure motionâ.
Physics suggests two kinds of things like this. The first are particles, like electrons or photons or quarks. And the second are black holes. As of now, we have no specific evidence that particles like electrons are âmade of anythingâ; they just seem to act like geometrical points. But in our Physics Project we posit that they are ultimately “made of space” and actually contain large numbers of atoms of space that collectively form some kind of persistent structure a bit like a vortex in a fluid.
Black holes operate on a very different scaleâthough I suspect theyâre actually very similar in character to particles. And in fact for black holes we already have a sense from traditional general relativity that they can just be âmade of spaceââthough without our discrete underlying model there are some inevitable mathematical hacks involved.
So what is it that leads to persistent structures? Often one can identify it as something âtopologicalâ. Thereâs an underlying âmediumâ in which all sorts of essentially continuous changes can be made. But then there are structures that canât be created or destroyed by such continuous changesâin effect because they are âtopologically distinctâ. Vortices are one such exampleâbecause around the core of the vortex, independent of what âcontinuous deformationsâ one makes, thereâs always a constant circulation of fluid, that canât be gotten rid of except by some kind of discontinuous change. (In reality, of course, vortices are eventually damped out by viscosity generated as a result of microscopic motion, but the point is that this takes a while, and until itâs happened, the vortex can reasonably be considered to persistently be a âthingâ.)
In our Physics Project, weâve already been able to figure out quite a bit about how black holes work. We know less about the specifics of how particles work. But the basic idea is that somehow there are features that are local and persistent that we can identify as particlesâand perhaps these features have topological origins that make it inevitable that, for example, all electrons âintrinsically seem the sameâ, and that there are only a discrete set of possible types of particles (at least at our energy scales).
So in the end what we imagine is that there are certain âcarriers of pure motionâ: certain collective features of space that are persistent enough that we can consider them to âjust moveâ, without changing. At the outset itâs not obvious that any such features should exist at all, and that pure motion should ever be possible. Unlike in the traditional âpure geometricalâ view of space, in our Physics Project itâs something one has to explicitly derive from the underlying structure of the modelâthough it seems quite likely that itâs ultimately an inevitable and ubiquitous consequence of rather general âtopologicalâ features of hypergraph rewriting.
We keep on talking about âfeatures that persistâ. But what does this really mean? As soon as something moves itâll be made of different atoms of space. So what does it mean for it to âpersistâ? In the end itâs all about what observers perceive. Do we view it as being the âsame thingâ but in a different place? Or do we say itâs different because some detail of it is different?
And actually this kind of issue already comes up even before weâre talking about motion and the persistence of âobjectsâ: itâs crucial just in the emergence of the basic notion of space itself. At the level of individual atoms of space there isnât anything we can really call âspaceâ, just like at the level of individual molecules there isnât anything we can reasonably call a fluid. And instead, the notion of spaceâor of fluidsâemerges when we look at things in the kind of way that observers like us do. Weâre not tracking whatâs happening at the level of individual atoms of spaceâor individual molecules; weâre looking at things in a more coarsegrained way, that it turns out we can summarize in terms of what amount to continuum concepts.
Once again, itâs not obvious things will work like this. Down at the level of atoms of spaceâor, for that matter, moleculesâthere are definite computational rules being followed. And from the Principle of Computational Equivalence itâs almost inevitable that thereâll be computational irreducibility, implying that thereâs no way to find the outcome except in effect by doing an irreducible amount of computational work. If we as observers were computationally unbounded then, yes, we could always âdecodeâ whatâs going on, and âsee downâ to the behavior of individual atoms of space or individual molecules. But if weâre computationally bounded we canât do this. And, as Iâve argued elsewhere, thatâs both why we believe in the Second Law of thermodynamics, and why we perceive there to be something like ordinary âgeometrical spaceâ.
In other words, our inability to track the details means that in a first approximation we can summarize whatâs going on just by saying weâve got something that seems like our ordinary notion of space. And going one step beyond that is what has us talking about âpersistent objects in spaceâ. But now weâre back to discussing what it means for an object to âbe persistentâ. Ultimately itâs that we as observers somehow perceive it to âbe the sameâ, even though perhaps in a âdifferent placeâ.
A key finding of our Physics Project is that certain basic laws of physicsâin particular general relativity and quantum mechanicsâinevitably seem to emerge as soon as we assume that observers have two basic characteristics: first, that they are computationally bounded, and second, that they are persistent in time.
In our Physics Project the passage of time corresponds to the inexorable (and irreducible) computational process of updating the âspatial hypergraphâ that represents the lowestlevel structure of the universe. And when we talk formally we can imagine looking at this âfrom the outsideâ. But in reality we as observers must be embedded within the system, being continually updated and changed just like the rest of the system.
But here thereâs a crucial point. Even though the particular configuration of atoms in our brains is continually changing, we think itâs âstill usâ. Or, in other words, we have the perception that we persist through time. Now it could be that this wouldnât be a consistent thing to imagine, and that if we imagined it, weâd never be able to form a coherent view of the world. But in fact what our Physics Project implies is that with this assumption we can (subject to various conditions) form a coherent view of the world, and itâs one where the core known laws of physics are in evidence.
OK, so we ourselves are persistent essentially because we assume that we are (and in most situations nothing goes wrong if we do this). But the persistence of something like a particle, or a black hole, is a different story. From our point of view, weâre not âinsideâ things like these; instead weâre âlooking at them from the outsideâ.
But what do we notice in them? Well, that depends on our âpowers of observationâ. The basic idea of particles, for example, is that they should be objects that can somehow be separated from each other and from everything else. In our Physics Project, though, any particle must ultimately be âembedded as a part of spaceâ. So when we say that itâs a âseparable objectâ what weâre imagining is just that thereâs some attribute of it that we can identify and observe independent of its âenvironmentâ.
But just what this is can depend on our characteristics as observers, and the fact that we operate on certain scales of length and time. If we were able to go down to the level of individual atoms of space we probably wouldnât be able to âseeâ that thereâs anything like a particle there at all. Thatâs something that emerges for observers with our kinds of characteristics.
Quite what the full spectrum of âconceivable persistent featuresâ might be isnât clear (though weâll see some exotic possibilities below). But as soon as one can identify a persistent feature, one can ask about motion. Is it possible for that feature to âmoveâ from being embedded at one âplaceâ to another?
Thereâs yet another subtlety here, though. Our ordinary experience of motion involves things going from one place to another by progressively âvisiting every place in betweenâ. But ultimately, as soon as weâre dealing with discrete atoms of space, this canât be how things work. And instead what we need to discuss is whether something somehow âmaintains its formâ at intermediate stages as it âmovesâ.
For example, we probably wouldnât consider it motion in the ordinary sense if what we had was a kind of Star Trek–like âtransporterâ in which objects get completely disassembled, then get âtransmitted to a different placeâ and reassembled. But somehow it does seem more like âordinary motionâ if thereâs a collection of pixel values that move across a computer screenâeven if at intermediate moments they are distorted by all sorts of aliasing effects.
Even in ordinary general relativity there are issues with the idea of motionâat least for extended objects. If weâre in a region of space thatâs reasonably flat itâs fine. But if weâre near a spacetime singularity then inevitably objects wonât be able to âmaintain their integrityââand instead theyâll effectively be âshreddedââand so canât be interpreted as âjust movingâ. When weâre dealing not with geometric continuum spacetime but instead with our spatial hypergraph, thereâll always be something analogous to âshreddingâ on a small enough scale, and the question is whether at the level we perceive things weâll be able to tell that thereâs something persistent that isnât shredded.
So, in the end, how is it that things can move? Ultimately itâs something that has to be formally derived from the underlying model, based on the characteristics of the observer. At least conceptually the first step is to identify what kinds of things the observer considers âthe sameâ, and what details make them âseem differentâ. Then one needs to determine whether there are structures that would be considered the same by the observer, but which progressively change âwhere theyâre embeddedâ. And if so, weâve identified âmotionâ.
For us humans with our current state of technological development, particles and objects made of them are the most obvious things to consider. So in a sense the question reduces to whether there are âlumps of spaceâ that persist in maintaining (perhaps topological) features recognized by our powers of perception. And to determine this is a formal question thatâs important to explore as our Physics Project progresses.
Weâve talked about âpersistent structuresâ as âcarriers of pure motionâ. But how do such structures actually work? Ultimately it can be a very complicated story. But here weâll consider a simplified case that begins to illustrate some of the issues. Weâll be talking not about the actual model of space in our Physics Project, but instead about the cellular automaton systems Iâve studied for many years in which space is effectively predefined to consist of a rigid array of cells, each with a discrete value updated according to a local rule.
Hereâs an example in which there quickly emerge obvious âlocalized persistent structuresâ that we can think of as being roughly like particles:
✕

Some âstay stillâ relative to the fixed cellular automaton background; others âmoveâ. With this specific cellular automaton, itâs easy to identify certain possible “particles”, some âstaying stillâ and some âshowing motionâ:
✕

But consider instead a cellular automaton with very different behavior:
✕

Does this support the concept of motion? Certainly not as obviously as the previous case. And in fact there doesnât seem to be anything identifiable that systematically propagates across the system. Or in other words, at least with our typical âpowers of perceptionâ we donât âsee motionâ here.
Thereâs a whole spectrum of more complicated cases, however. Consider for example:
✕

Here one can easily identify âparticlelikeâ structures, but they never seem to âkeep moving foreverâ; instead they always fairly quickly interact and âannihilateâ. But to expect otherwise is to imagine an idealization in which there is at some level âonly one objectâ in the whole system. As soon as there are multiple objects itâs basically inevitable that theyâll eventually interact. Or, put another way, motion in any real situation will never be about âpersistently movingâ forever; itâs just about persisting for at least long enough to be identified as something separate and definite. (This is very similar to the situation in quantum field theory where actual particles eventually interact, even though their formal definition assumes no interaction.)
Hereâs another case, where on a large scale thereâs no âobvious motionâ to be seen
✕

but where locally one can identify rather simple âparticlelikeâ structures
✕

that on their own can be thought of as âexhibiting motionâ, even though there are other structures that for example just expand, apparently without bound:
✕

Sometimes there can be lots of âparticlelikeâ activity, but with other things consistently mixed in:
✕

Hereâs a slightly more exotic example, where continual âstreams of particlesâ are produced:
✕

In all the examples weâve seen so far the âparticlesâ exist on a âblankâ or otherwise simple background. But itâs also perfectly possible for them to be on a background with more elaborate structure:
✕

But what about a seemingly random background? Hereâs at least a partial example where there are both structures that ârespond to the backgroundâ and ones that have âintrinsic particlelike formâ:
✕

What does all this mean for the concept of motion? The most important point is that weâve seen that âobjectsâ that can be thought of as âshowing pure motionâ can emerge even in underlying systems that donât seem to have any particular âbuiltin concept of motionâ. But what weâve also seen is that along with âobjects that show pure motionâ there can be all sorts of other effects and phenomena. And in our actual Physics Project these can necessarily in a sense be much more extreme.
The cellular automaton systems weâve been discussing so far have a builtin underlying notion of space, which exists even if the system basically âdoesnât do anythingâ. But in our Physics Project the structure of space itself is created through activity. Soâas we discussed in the previous sectionââobjectsâ or particles have to somehow exist âon topâ of this.
Itâs fairly clear roughly how such particles must work, being based for example on essentially topological features of the system. But we donât yet know the details, and thereâs probably quite a depth of mathematical formalism that needs to be built to clarify them. Itâs still possible, though, to explore at least some toy examples.
Consider the hypergraph rewriting rule:
✕

It maintains a very simple (effectively 1D and cyclic) form of space (with rewrites shown in red):
✕

If the initial conditions contain a feature that can be interpreted as something like a âparticleâ then the rules are such that this can âmove aroundâ, but canât be destroyed:
✕

Itâs a little clearer whatâs going on if instead of looking at an explicit sequence of hypergraphs we instead generate causal graphs (see the next section) that show the âspacetimeâ network of causal relationships between updating events. Hereâs the causal graph for the âspace only, no particlesâ case (where here we can think of time as effectively running from left to right):
✕

Hereâs the causal graph when thereâs a âparticleâ included:
✕

And hereâs the result when there are âtwo particlesââwhere things begin to get more complicated:
✕

Weâve discussed what it takes for an observer to identify something as âmovingâ in a system. But so far thereâs an important piece weâve left out. Because in effect weâve assumed that the observer is âoutside the systemâ and âlooking inâ. But if we imagine that weâre dealing with a complete model of the physical universe the observer necessarily has to âbe insideâ. And ultimately the observer has got to be âmade of the same stuffâ as whatever thing it is to which weâre attributing motion.
How does an observer observe? Ultimately whatever is âhappening in the outside worldâ must affect the observer, and the observer must change as a result. Our Physics Project has a fundamental way to think about change, in terms of elementary âupdating eventsâ. In addition to imagining that space is made up of discrete âatoms of spaceâ, we imagine that change is made up of discrete âatoms of changeâ or âeventsâ.
In the hypergraph that represents space and everything in it, each event updates (or ârewritesâ) the hypergraph, by âconsumingâ some collection of hyperedges, and generating a new collection. But actually events are a more general concept that donât for example depend on having an underlying hypergraph. We can just think of them as consuming collections of “tokens”, whatever they may be, and generating new ones.
But events satisfy a very important constraint, which in some sense is responsible for the very existence of what we think of as time. And the constraint is that for any event to happen, all the tokens itâs going to consume have to exist. But those tokens have to have âcome from somewhereâ. And at least if we ignore what happens âat the very beginningâ every token thatâs going to be consumed has to have been generated by some other event. In other words, thereâs a certain necessary ordering among events. And we can capture this by constructing a causal graph that captures the causal relationships that must exist between events.
As a simple example, hereâs a system that consists of a string of As and Bs, and in which each âupdating eventâ (indicated as a yellow box) corresponds to an application of the rule BA→AB:
✕

Hereâs the causal graph for this superimposed:
✕

Imagine that some collection of characters on the lefthand side represents âan observerâ. The only way this observer can be affected by what happens on the righthand side is as a result of its events being affected by events on the righthand side. But what event is affected by what other event is exactly what the causal graph defines. And so in the end we can say that what the observer can âperceiveâ is just the causal graph of causal relationships between events.
âFrom the outsideâ we might see some particular âabsoluteâ arrangement of events in the cellularautomatonlike picture above. But the point is that âfrom the insideâ the observer canât perceive this âabsolute arrangementâ. All they can perceive is the causal graph. Or, put another way, the observer doesnât have any âabsolute knowledgeâ of the system; all they âknow aboutâ is âeffects on themâ.
So what does this imply about motion? In something like a cellular automaton thereâs a fixed concept of space that we typically âlook at from the outsideââand we can readily âsee whatâs movingâ relative to that fixed, absolute âbackground spaceâ. But in something like our Physics Project we imagine that any observer must be inside the system, able to âtell whatâs going onâ only from the causal graph.
In standard physics we might posit that to find out âwhere something isâ weâd have to probe it, say with light signals. Here weâve broken everything down to the level of elementary events and weâre in some sense ârepresenting everything that can happenâ in terms of the causal graph of relationships between events.
And in fact as soon as we assume that our âperceived realityâ has to be based on the causal graph, weâve inevitably abandoned any absolute notion of space. All we as observers can know is ârelative informationâ, defined for us by the causal graph.
Looking at our BA→AB system above we can see that âviewed from the outsideâ thereâs a lot of arbitrariness in âwhen we doâ each update. But it turns out that none of this matters to the causal graph we constructâbecause this particular underlying system has the property of causal invariance, which makes the causal graph have the same structure independent of these choices. And in general whenever thereâs causal invariance (which there inevitably will be at least at the ultimate level of the ruliad) this has the important implication that thereâs relativistic invariance in the system.
We wonât go into this in detail here. Because while it certainly affects the specifics of how motion works there are more fundamental issues to discuss about the underlying concept of motion itself.
Weâve already discussed the idea that observers like us posit our own persistence through time. But now we can be a bit more preciseâand say that what we really posit is that we âfollow the causal graphâ. It could be that our perception samples all sorts of eventsâthat we might think of as being âall over spacetimeâ. But in fact we assume that we donât âjump around the causal graphâ, and that instead our experiences are based on âcoherent pathsâ through the causal graph.
We never in any absolute sense âknow where we areâ. But we construct our notion of place by positing that we exist at a definiteâand in a sense âcoherentââplace, relative to which we perceive other things. If our perception of âwhere we areâ could âjump aroundâ the causal graph, weâd never be able to define a coherent concept of pure motion.
To make this a little bit âmore practicalâ letâs discuss (as I did some time ago) the question of fasterthanlight travel in our Physics Project. By the very definition of the causal graph the effect of one event on another is represented by the presence of a âcausal pathâ between the events within the graph. We can assume that âtraversingâ each âcausal edgeâ (i.e. going from one event to the next) takes a certain elementary time. But to work out âhow fast the effect propagatedâ we need to know how âfar away in spaceâ the event that was affected is.
But recall that all the observer ultimately has available is the causal graph. So any questions about âdistances in spaceâ have to be deduced from the causal graph. And the nature of the observerâand the assumptions they make about themselvesâinevitably affect the deductions they make.
Imagine a causal graph that is mostly a grid, but suppose there is a single edge that âjumps across the gridâ, connecting events that would otherwise be distant in the graph. If we as observers were sensitive to that single edge itâd make us think that the two events it joins are âvery close togetherâ. But if we look only at the âbulk structureâ of the causal graph, weâd ignore that edge in our definition of the âlayout of spaceâ, and consider it only as some kind of âmicroscopic anomalyâ.
So should we in fact include that single edge when we define our concept of motion? If we posit that we âexist at a definite placeâ then the presence of such an edge in what âconstitutes usâ means the âplace weâre atâ must extend to wherever in the causal graph the edge reaches. But if there are enough âstray edgesâ (or in general what I call “space tunnels”) we as observers would inevitably get very âdelocalizedâ.
To be able to âobserve motionâ weâd better be observers who can coherently form a notion of space in which there can be consistent âlocal placesâ. And if thereâs some elaborate pattern of space tunnels this could potentially be broken. Although ultimately it wonât be unless the space tunnels are somehow coherent enough to âget observers like us through themâ.
Earlier we saw that the concept of motion depends on the idea that we as observers can identify âthingsâ as âpersistentâ relative to the âbackground structure of spaceâ. And now we can see that in fact motion depends on a certain persistence in time and âcoherenceâ in place not only for the âthingâ we posit is moving, but also for us as observers observing it.
In our Physics Project we imagine that both time and space are fundamentally discrete. But the concept of persistenceâor âcoherenceââimplies that at least at the level of our perception there must be a certain effectively continuous character to them. Thereâs a certain resonance with things like Zenoâs paradoxes. Yes, our models may define only what happens at a sequence of discrete steps. But the perception that we persistently exist will make us effectively fill in all the âintervening momentsââto form what we experience as a âcontinuous thread of existenceâ.
The idea that pure motion is possible is thus intimately connected to the idea of the continuum. Pure motion in a sense posits that there is some kind of âthread of existenceâ for âthingsâ that leads from one place and time to another. But ultimately all thatâs relevant is that observers like us perceive there to be such a thread. And the whole point is that the possibility of such perception can be deduced as a matter of formal derivation from the structure of the underlying model and general characteristics of us as observers.
But in describing our perception what weâll tend to do is to talk in terms of the continuum. Because thatâs the level of description at which we can abstractly discuss pure motion, without having to get into the mechanics of how it happens. And in effect the âderivation of pure motionâ is thus directly connected to the âderivation of the continuumâ: pure motion is in a sense an operational consequence not necessarily of an actual continuum world, but of a continuum perception of the world by an embedded observer like us.
Our everyday experience of motion has to do with ordinary, physical space. But the multicomputational paradigm inspired by our Physics Project inevitably leads to other kinds of spaceâthat are different in character and interpretation from ordinary, physical space, but have deep analogies to it. So in the context of these other kinds of space, what analogs of the concept of âpure motionâ might there be?
Letâs talk first about branchial space, which in our Physics Project is interpreted as the space of quantum states. To approach this from a simple example, letâs consider the multiway graph generated by applying the rule {A→AB,B→A} in all possible ways to each âstateâ:
✕

We can think of each path through this graph as defining a possible history for the system, leading to a complicated pattern of possible âthreads of historyâ, sometimes branching and sometimes merging. But now consider taking a âbranchial sliceâ across this systemâand then characterizing the âmulticomputational behaviorâ of the system by constructing what we call the branchial graph by joining states that share an ancestor on the step before:
✕

For physics, we interpret the nodes of these graphs as quantum states, so that the branchial graph effectively gives us a âmap of quantum entanglementsâ between states. And just like for the hypergraph that we imagine defines the relations between the atoms of physical space, we think about the limit of a very large branchial graphâthat gives us what we can call branchial space. As weâve discussed elsewhere, branchial space is in many ways much wilder than ordinary, physical space, and is for example probably exponentialdimensional.
In basic quantum mechanics, distances in branchial space are probably related to differences in phase between quantum amplitudes. In more complicated cases they probably correspond to more complicated transformations between quantum states. So how might we think about âmotionâ in branchial space?
Although weâve discussed it at length elsewhere, we didnât above talk about what we might call âbulk motionâ in physical space, as effectively produced by the curvature of space associated with gravity. But in branchial space there seems to be a directly analogous phenomenonâin which the presence of energy (which corresponds to the density of activity in the system) leads to an effective curvature in branchial space which deflects all paths, in a way that seems to produce the change of quantum phase specified by the path integral.
But can we identify specific things moving and preserving their identity in branchial space, as we can identify things like particles moving in physical space? Itâs a tricky story, incompletely figured out, and deeply connected to issues of quantum measurement. But just like in physical space, an important issue is to define what âobservers like usâ are like. And a crucial first step is to realize thatâas entities embedded in the universeâwe must inevitably have multiple histories. So to ask how we perceive what happens in the universe is in effect to ask how a âbranching mindâ perceives a branching universe.
And the crucial pointâdirectly analogous to what weâve discussed in the case of physical spaceâis that whatever one might be able to âsee from outsideâ, we âinternallyâ assume that we as observers have a certain persistence and coherence. In particular, even though âfrom the outsideâ the multiway graph might show many branching threads of history, our perception is that we have a single thread of experience.
In ordinary quantum mechanics, itâs quite tricky to see how this âconflation of threads of historyâ interacts even with âbulk motionâ in branchial space. Typically, as in traditional quantum measurement, one just considers âsnapshotsâ at particular times. Yes, one can imagine that things like wave packets spread out in branchial space, butâa bit like discussing âmotionâ for gravitational fields or even gravitational waves in spacetimeâthere isnât the same kind of systematic concept of pure motion that weâve encountered with things like particles in physical space.
When we get to quantum field theoryâor the full quantum gravity associated with our modelsâit will probably be a different story. Perhaps we can view certain configurations of quantum fields as being like structures in branchial space, that an observer will consider to be localized and persistent. Indeed, itâs easy to imagine that in the branchial graphâor even more so the multiway causal graphâthere may be things like âtopologically stableâ structures that we can reasonably think of as âthings that moveâ. But just what the character and interpretation of such things might be, we donât yet know.
Thereâs physical space, and thereâs branchial space. But in a sense the ultimate kind of space is rulial space. The story begins with the ruliad, which represents the entangled limit of all possible computations. The ruliad is what we imagine underlies not only physics but also mathematics. When we âexperience physicsâ weâre sampling a certain slice of the ruliad thatâs accessible to physical observers like us. And when we âexperience mathematicsâ weâre sampling a slice of the ruliad thatâs accessible to âmathematical observersâ like us.
So what do different âplacesâ in rulial space correspond to? Fundamentally theyâre different choices for the rules we sample from the ruliad. Ultimately everything is part of the unique object that is the ruliad. But at different places in the ruliad weâll have different specific experiences as observers.
Inevitably, though, thereâs a translation that can be made. Itâs basically like the situation with different computational systems thatâaccording to the Principle of Computational Equivalenceâare generically universal: thereâs always an âinterpreterâ that can be created in one system that can translate to the other.
In a sense the idea of different places in rulial space is quite familiar from our everyday experience. Because itâs directly analogous to the idea that different minds âparseâ and âexperienceâ the world differently. Whether oneâs talking about a human brain or an artificial neural net, the details of its past experience will cause it to represent things in the world in different ways, and to process them differently.
At the very lowest level, the components of the systems willâlike any other universal computerâbe able to emulate the detailed operations of other systems. But at this level there are no âthings that are moving from one place to another in rulial spaceâ; everything is just being âatomizedâ.
So are there in fact robust structures that can âmove across rulial spaceâ? The answer, I think, is yes. But itâs a strange story. I suspect that the analog in rulial space of particles in physical space is basically conceptsâsay of the kind that might be represented by words in a human (or computational) language.
Imagine thinking about a cat. Thereâs a particular representation of a cat in oneâs brainâand in detail itâll be different from the representation in anyone elseâs brain. But now imagine using the word âcatâ, or in some way communicating the concept of âcatâ. The âcatâ concept is something robust, that weâre used to seeing âtransmittedâ from one brain to anotherâeven though different brains represent it differently.
Things might not work this way. It could be that thereâd be no robust way to transmit anything about the thinking going on in one brain to another brain. But thatâs where the idea of concepts comes in. Theyâre an abstracted way to âtransportâ some feature of thinking in one brain to another.
And in a sense theyâre a reflection of the possibility of pure motion in rulial space: theyâre a way to have some kind of persistent âthingâ that can be traced across rulial space.
But just like our examples of motion, the way this works depends on the characteristics of the observers observing itâand insofar as we are the observers, it therefore depends on us. We know from experience that we form concepts, and that they have a certain robustness. But why is this? In a sense, concepts are a way of coarsegraining things so that weâas computationally bounded entitiesâcan deal with them. And the fact that we take concepts to maintain some kind of fixed meaning is part of our perception that we maintain a single persistent thread of experience.
It is strange to think that something as explicit and concrete as an electron in physical space could in some sense be similar to an abstract concept like âcatâ. But this is the kind of thing that happens when one has something as fundamental and general as the ruliad underlying everything.
We know that our general characteristics as observers inevitably lead to certain general laws of physics. And so similarly we can expect that our general characteristics as observers will lead to certain general laws about the overall representation of things. Perhaps weâll be able to identify analogs of energy and gravity and quantum mechanics. But a first step is to identify the analog of motion, and the kinds of things which can exhibit pure motion.
In physical space, particles like electrons are our basic âcarriers of motionâ. In rulial space âconceptsâ seem to be our best description of the âcarriers of motionâ (though there are presumably higherlevel constructs too, like analogies and syntactic structures). And, yes, it might seem very odd to say that something as apparently humancentered as âconceptsâ can be associated with something as fundamental as motion. But as weâve emphasized several times here, âpure motionâ is something that relies on the observer, and on the observer having what amounts to a âsensory apparatusâ that considers a âthingâ to maintain a persistent character. So when it comes to the representation of âarbitrary contentâ itâs not surprising that we as observers have to talk about the fundamental way we think about things, and about constructs like concepts.
But are things like concepts the only kind of persistent structures that can exist in rulial space? Theyâre ones that we as observers can readily parse out of the ruliadâbased for example on the particular ways of thinking that weâve embraced so far in our intellectual development. But we can certainly imagine that thereâs the possibility for ârobust communicationâ independent, for example, of human minds.
Thereâs a great tendency, though, to try to relate things back to human constructs. For example, we might consider a machinelearning system thatâs successfully discovered a distinction that can repeatedly be used for some purpose. And, yes, we can imagine âtransportingâ that to a different system. But weâll tend to think of this again in terms of some âfeatureâ or âconceptâ, even though, for example, we might not happen (at least yet) to have some word for it in a human language, or a computational language intended for use by humans.
We can similarly talk about communication with or between other animals, or, more ambitiously, we can discuss communications with or between “alien intelligences”. We might assume that we would be able to say nothing about such cases. But ultimately we imagine that everything is represented somewhere in the ruliad. And in effect by doing things like exploring arbitrarily chosen programs we can investigate possible âraw materialâ for âalien intelligenceâ.
And itâs then at some level a matter of scienceâor, more specifically, ruliologyâto try to identify âtransportable elementsâ between different programs, or, in effect, between different places in rulial space. At a simple level we might say weâre looking for âcommon principlesââwhich puts us back to something like âconceptsâ. But in general we can imagine a more elaborate computational structure for our âtransportable elementsâ in rulial space.
In physical space we know that we can make âmaterial objectsâ out of particles like electrons and quarks, and then âmove these aroundâ in physical space. Within the domain of âhumanthinking rulial spaceâ we can do something analogous with descriptions âmade from known conceptsâ. And in both cases we can imagine that there are more general constructs that are âpossibleâ, even though we human observers as we are now might not be able to âparse them out of the ruliadâ.
The constraints of computational boundedness and perception of persistence are probably pretty fundamental to any form of experience that can be connected to us. But as we develop what amount to new sensory capabilities or new ways of thinking we can expect that our ârangeâ as observers will at least somewhat increase.
And in a sense our very exploration of the concept of motion here can be thought of as a way to make possible a little bit more motion in rulial space. The concept of motion is a very general one. And one that we now see is deeply tied into ideas about observers and multicomputation. The question of how things can move is the same one that was asked in antiquity. But the tower of ideas that we can now bring to bear in answering is very different, and itâs sobering to see just how far we really were earlier in intellectual history from being able to meaningfully address it.
]]>One of the many surprising (and to me, unexpected) implications of our Physics Project is its suggestion of a very deep correspondence between the foundations of physics and mathematics. We might have imagined that physics would have certain laws, and mathematics would have certain theories, and that while they might be historically related, there wouldnât be any fundamental formal correspondence between them.
But what our Physics Project suggests is that underneath everything we physically experience there is a single very general abstract structureâthat we call the ruliadâand that our physical laws arise in an inexorable way from the particular samples we take of this structure. We can think of the ruliad as the entangled limit of all possible computationsâor in effect a representation of all possible formal processes. And this then leads us to the idea that perhaps the ruliad might underlie not only physics but also mathematicsâand that everything in mathematics, like everything in physics, might just be the result of sampling the ruliad. ]]>
One of the many surprising (and to me, unexpected) implications of our Physics Project is its suggestion of a very deep correspondence between the foundations of physics and mathematics. We might have imagined that physics would have certain laws, and mathematics would have certain theories, and that while they might be historically related, there wouldnât be any fundamental formal correspondence between them.
But what our Physics Project suggests is that underneath everything we physically experience there is a single very general abstract structureâthat we call the ruliadâand that our physical laws arise in an inexorable way from the particular samples we take of this structure. We can think of the ruliad as the entangled limit of all possible computationsâor in effect a representation of all possible formal processes. And this then leads us to the idea that perhaps the ruliad might underlie not only physics but also mathematicsâand that everything in mathematics, like everything in physics, might just be the result of sampling the ruliad.
Of course, mathematics as itâs normally practiced doesnât look the same as physics. But the idea is that they can both be seen as views of the same underlying structure. What makes them different is that physical and mathematical observers sample this structure in somewhat different ways. But since in the end both kinds of observers are associated with human experience they inevitably have certain core characteristics in common. And the result is that there should be âfundamental laws of mathematicsâ that in some sense mirror the perceived laws of physics that we derive from our physical observation of the ruliad.
So what might those fundamental laws of mathematics be like? And how might they inform our conception of the foundations of mathematics, and our view of what mathematics really is?
The most obvious manifestation of the mathematics that we humans have developed over the course of many centuries is the few million mathematical theorems that have been published in the literature of mathematics. But what can be said in generality about this thing we call mathematics? Is there some notion of what mathematics is like âin bulkâ? And what might we be able to say, for example, about the structure of mathematics in the limit of infinite future development?
When we do physics, the traditional approach has been to start from our basic sensory experience of the physical world, and of concepts like space, time and motionâand then to try to formalize our descriptions of these things, and build on these formalizations. And in its early developmentâfor example by Euclidâmathematics took the same basic approach. But beginning a little more than a century ago there emerged the idea that one could build mathematics purely from formal axioms, without necessarily any reference to what is accessible to sensory experience.
And in a way our Physics Project begins from a similar place. Because at the outset it just considers purely abstract structures and abstract rulesâtypically described in terms of hypergraph rewritingâand then tries to deduce their consequences. Many of these consequences are incredibly complicated, and full of computational irreducibility. But the remarkable discovery is that when sampled by observers with certain general characteristics that make them like us, the behavior that emerges must generically have regularities that we can recognize, and in fact must follow exactly known core laws of physics.
And already this begins to suggest a new perspective to apply to the foundations of mathematics. But thereâs another piece, and thatâs the idea of the ruliad. We might have supposed that our universe is based on some particular chosen underlying rule, like an axiom system we might choose in mathematics. But the concept of the ruliad is in effect to represent the entangled result of ârunning all possible rulesâ. And the key point is then that it turns out that an âobserver like usâ sampling the ruliad must perceive behavior that corresponds to known laws of physics. In other words, without âmaking any choiceâ it’s inevitableâgiven what weâre like as observersâthat our âexperience of the ruliadâ will show fundamental laws of physics.
But now we can make a bridge to mathematics. Because in embodying all possible computational processes the ruliad also necessarily embodies the consequences of all possible axiom systems. As humans doing physics weâre effectively taking a certain sampling of the ruliad. And we realize that as humans doing mathematics weâre also doing essentially the same kind of thing.
But will we see âgeneral laws of mathematicsâ in the same kind of way that we see âgeneral laws of physicsâ? It depends on what weâre like as âmathematical observersâ. In physics, there turn out to be general lawsâand concepts like space and motionâthat we humans can assimilate. And in the abstract it might not be that anything similar would be true in mathematics. But it seems as if the thing mathematicians typically call mathematics is something for which it isâand where (usually in the end leveraging our experience of physics) itâs possible to successfully carve out a sampling of the ruliad thatâs again one we humans can assimilate.
When we think about physics we have the idea that thereâs an actual physical reality that existsâand that we experience physics within this. But in the formal axiomatic view of mathematics, things are different. Thereâs no obvious âunderlying realityâ there; instead thereâs just a certain choice we make of axiom system. But now, with the concept of the ruliad, the story is different. Because now we have the idea that âdeep underneathâ both physics and mathematics thereâs the same thing: the ruliad. And that means that insofar as physics is âgrounded in realityâ, so also must mathematics be.
When most working mathematicians do mathematics it seems to be typical for them to reason as if the constructs theyâre dealing with (whether they be numbers or sets or whatever) are âreal thingsâ. But usually thereâs a concept that in principle one could âdrill downâ and formalize everything in terms of some axiom system. And indeed if one wants to get a global view of mathematics and its structure as it is today, it seems as if the best approach is to work from the formalization thatâs been done with axiom systems.
In starting from the ruliad and the ideas of our Physics Project weâre in effect positing a certain âtheory of mathematicsâ. And to validate this theory we need to study the âphenomena of mathematicsâ. And, yes, we could do this in effect by directly âreading the whole literature of mathematicsâ. But itâs more efficient to start from whatâs in a sense the âcurrent prevailing underlying theory of mathematicsâ and to begin by building on the methods of formalized mathematics and axiom systems.
Over the past century a certain amount of metamathematics has been done by looking at the general properties of these methods. But most often when the methods are systematically used today, itâs to set up some particular mathematical derivation, normally with the aid of a computer. But here what we want to do is think about what happens if the methods are used âin bulkâ. Underneath there may be all sorts of specific detailed formal derivations being done. But somehow what emerges from this is something higher level, something âmore humanââand ultimately something that corresponds to our experience of pure mathematics.
How might this work? We can get an idea from an analogy in physics. Imagine we have a gas. Underneath, it consists of zillions of molecules bouncing around in detailed and complicated patterns. But most of our âhumanâ experience of the gas is at a much more coarsegrained levelâwhere we perceive not the detailed motions of individual molecules, but instead continuum fluid mechanics.
And so it is, I think, with mathematics. All those detailed formal derivationsâfor example of the kind automated theorem proving might doâare like molecular dynamics. But most of our âhuman experience of mathematicsââwhere we talk about concepts like integers or morphismsâis like fluid dynamics. The molecular dynamics is what builds up the fluid, but for most questions of âhuman interestâ itâs possible to âreason at the fluid dynamics levelâ, without dropping down to molecular dynamics.
Itâs certainly not obvious that this would be possible. It could be that one might start off describing things at a âfluid dynamicsâ levelâsay in the case of an actual fluid talking about the motion of vorticesâbut that everything would quickly get âshreddedâ, and that thereâd soon be nothing like a vortex to be seen, only elaborate patterns of detailed microscopic molecular motions. And similarly in mathematics one might imagine that one would be able to prove theorems in terms of things like real numbers but actually find that everything gets âshreddedâ to the point where one has to start talking about elaborate issues of mathematical logic and different possible axiomatic foundations.
But in physics we effectively have the Second Law of thermodynamicsâwhich we now understand in terms of computational irreducibilityâthat tells us that thereâs a robust sense in which the microscopic details are systematically âwashed outâ so that things like fluid dynamics âworkâ. Just sometimesâlike in studying Brownian motion, or hypersonic flowâthe molecular dynamics level still âshines throughâ. But for most âhuman purposesâ we can describe fluids just using ordinary fluid dynamics.
So whatâs the analog of this in mathematics? Presumably itâs that thereâs some kind of âgeneral law of mathematicsâ that explains why one can so often do mathematics âpurely in the largeâ. Just like in fluid mechanics there can be âcornercaseâ questions that probe down to the âmolecular scaleââand indeed thatâs where we can expect to see things like undecidability, as a rough analog of situations where we end up tracing the potentially infinite paths of single molecules rather than just looking at âoverall fluid effectsâ. But somehow in most cases thereâs some much stronger phenomenon at workâthat effectively aggregates lowlevel details to allow the kind of âbulk descriptionâ that ends up being the essence of what we normally in practice call mathematics.
But is such a phenomenon something formally inevitable, or does it somehow depend on us humans âbeing in the loopâ? In the case of the Second Law itâs crucial that we only get to track coarsegrained features of a gasâas we humans with our current technology typically do. Because if instead we watched and decoded what every individual molecule does, we wouldnât end up identifying anything like the usual bulk âSecondLawâ behavior. In other words, the emergence of the Second Law is in effect a direct consequence of the fact that itâs us humansâwith our limitations on measurement and computationâwho are observing the gas.
So is something similar happening with mathematics? At the underlying âmolecular levelâ thereâs a lot going on. But the way we humans think about things, weâre effectively taking just particular kinds of samples. And those samples turn out to give us âgeneral laws of mathematicsâ that give us our usual experience of âhumanlevel mathematicsâ.
To ultimately ground this we have to go down to the fully abstract level of the ruliad, but weâll already see many core effects by looking at mathematics essentially just at a traditional âaxiomatic levelâ, albeit âin bulkâ.
The full storyâand the full correspondence between physics and mathematicsârequires in a sense âgoing belowâ the level at which we have recognizable formal axiomatic mathematical structures; it requires going to a level at which weâre just talking about making everything out of completely abstract elements, which in physics we might interpret as âatoms of spaceâ and in mathematics as some kind of âsymbolic raw materialâ below variables and operators and everything else familiar in traditional axiomatic mathematics.
The deep correspondence weâre describing between physics and mathematics might make one wonder to what extent the methods we use in physics can be applied to mathematics, and vice versa. In axiomatic mathematics the emphasis tends to be on looking at particular theorems and seeing how they can be knitted together with proofs. And one could certainly imagine an analogous âaxiomatic physicsâ in which one does particular experiments, then sees how they can âdeductivelyâ be knitted together. But our impression that thereâs an âactual realityâ to physics makes us seek broader laws. And the correspondence between physics and mathematics implied by the ruliad now suggests that we should be doing this in mathematics as well.
What will we find? Some of it in essence just confirms impressions that working pure mathematicians already have. But it provides a definite framework for understanding these impressions and for seeing what their limits may be. It also lets us address questions like why undecidability is so comparatively rare in practical pure mathematics, and why it is so common to discover remarkable correspondences between apparently quite different areas of mathematics. And beyond that, it suggests a host of new questions and approaches both to mathematics and metamathematicsâthat help frame the foundations of the remarkable intellectual edifice that we call mathematics.
If we âdrill downâ to what weâve called above the âmolecular levelâ of mathematics, what will we find there? There are many technical details (some of which weâll discuss later) about the historical conventions of mathematics and its presentation. But in broad outline we can think of there as being a kind of âgasâ of âmathematical statementsââlike 1 + 1 = 2 or x + y = y + xârepresented in some specified symbolic language. (And, yes, Wolfram Language provides a welldeveloped example of what that language can be like.)
But how does the âgas of statementsâ behave? The essential point is that new statements are derived from existing ones by âinteractionsâ that implement laws of inference (like that q can be derived from the statement p and the statement âp implies qâ). And if we trace the paths by which one statement can be derived from others, these correspond to proofs. And the whole graph of all these derivations is then a representation of the possible historical development of mathematicsâwith slices through this graph corresponding to the sets of statements reached at a given stage.
By talking about things like a âgas of statementsâ weâre making this sound a bit like physics. But while in physics a gas consists of actual, physical molecules, in mathematics our statements are just abstract things. But this is where the discoveries of our Physics Project start to be important. Because in our project weâre âdrilling downâ beneath for example the usual notions of space and time to an âultimate machine codeâ for the physical universe. And we can think of that ultimate machine code as operating on things that are in effect just abstract constructsâvery much like in mathematics.
In particular, we imagine that space and everything in it is made up of a giant network (hypergraph) of âatoms of spaceââwith each âatom of spaceâ just being an abstract element that has certain relations with other elements. The evolution of the universe in time then corresponds to the application of computational rules that (much like laws of inference) take abstract relations and yield new relationsâthereby progressively updating the network that represents space and everything in it.
But while the individual rules may be very simple, the whole detailed pattern of behavior to which they lead is normally very complicatedâand typically shows computational irreducibility, so that thereâs no way to systematically find its outcome except in effect by explicitly tracing each step. But despite all this underlying complexity it turns outâmuch like in the case of an ordinary gasâthat at a coarsegrained level there are much simpler (âbulkâ) laws of behavior that one can identify. And the remarkable thing is that these turn out to be exactly general relativity and quantum mechanics (which, yes, end up being the same theory when looked at in terms of an appropriate generalization of the notion of space).
But down at the lowest level, is there some specific computational rule thatâs ârunning the universeâ? I donât think so. Instead, I think that in effect all possible rules are always being applied. And the result is the ruliad: the entangled structure associated with performing all possible computations.
But what then gives us our experience of the universe and of physics? Inevitably we are observers embedded within the ruliad, sampling only certain features of it. But what features we sample are determined by the characteristics of us as observers. And what seem to be critical to have âobservers like usâ are basically two characteristics. First, that we are computationally bounded. And second, that we somehow persistently maintain our coherenceâin the sense that we can consistently identify what constitutes âusâ even though the detailed atoms of space involved are continually changing.
But we can think of different âobservers like usâ as taking different specific samples, corresponding to different reference frames in rulial space, or just different positions in rulial space. These different observers may describe the universe as evolving according to different specific underlying rules. But the crucial point is that the general structure of the ruliad implies that so long as the observers are âlike usâ, itâs inevitable that their perception of the universe will be that it follows things like general relativity and quantum mechanics.
Itâs very much like what happens with a gas of molecules: to an âobserver like usâ there are the same gas laws and the same laws of fluid dynamics essentially independent of the detailed structure of the individual molecules.
So what does all this mean for mathematics? The crucial and at first surprising point is that the ideas weâre describing in physics can in effect immediately be carried over to mathematics. And the key is that the ruliad represents not only all physics, but also all mathematicsâand it shows that these are not just related, but in some sense fundamentally the same.
In the traditional formulation of axiomatic mathematics, one talks about deriving results from particular axiom systemsâsay Peano Arithmetic, or ZFC set theory, or the axioms of Euclidean geometry. But the ruliad in effect represents the entangled consequences not just of specific axiom systems but of all possible axiom systems (as well as all possible laws of inference).
But from this structure that in a sense corresponds to all possible mathematics, how do we pick out any particular mathematics that weâre interested in? The answer is that just as we are limited observers of the physical universe, so we are also limited observers of the âmathematical universeâ.
But what are we like as âmathematical observersâ? As Iâll argue in more detail later, we inherit our core characteristics from those we exhibit as âphysical observersâ. And that means that when we âdo mathematicsâ weâre effectively sampling the ruliad in much the same way as when we âdo physicsâ.
We can operate in different rulial reference frames, or at different locations in rulial space, and these will correspond to picking out different underlying ârules of mathematicsâ, or essentially using different axiom systems. But now we can make use of the correspondence with physics to say that we can also expect there to be certain âoverall laws of mathematicsâ that are the result of general features of the ruliad as perceived by observers like us.
And indeed we can expect that in some formal sense these overall laws will have exactly the same structure as those in physicsâso that in effect in mathematics weâll have something like the notion of space that we have in physics, as well as formal analogs of things like general relativity and quantum mechanics.
What does this mean? It implies thatâjust as itâs possible to have coherent âhigherlevel descriptionsâ in physics that donât just operate down at the level of atoms of space, so also this should be possible in mathematics. And this in a sense is why we can expect to consistently do what I described above as âhumanlevel mathematicsâ, without usually having to drop down to the âmolecular levelâ of specific axiomatic structures (or below).
Say weâre talking about the Pythagorean theorem. Given some particular detailed axiom system for mathematics we can imagine using it to build up a preciseâif potentially very long and pedanticârepresentation of the theorem. But letâs say we change some detail of our axioms, say associated with the way they talk about sets, or real numbers. Weâll almost certainly still be able to build up something we consider to be âthe Pythagorean theoremââeven though the details of the representation will be different.
In other words, this thing that we as humans would call âthe Pythagorean theoremâ is not just a single point in the ruliad, but a whole cloud of points. And now the question is: what happens if we try to derive other results from the Pythagorean theorem? It might be that each particular representation of the theoremâcorresponding to each point in the cloudâwould lead to quite different results. But it could also be that essentially the whole cloud would coherently lead to the same results.
And the claim from the correspondence with physics is that there should be âgeneral laws of mathematicsâ that apply to âobservers like usâ and that ensure that thereâll be coherence between all the different specific representations associated with the cloud that we identify as âthe Pythagorean theoremâ.
In physics it could have been that weâd always have to separately say what happens to every atom of space. But we know that thereâs a coherent higherlevel description of spaceâin which for example we can just imagine that objects can move while somehow maintaining their identity. And we can now expect that itâs the same kind of thing in mathematics: that just as thereâs a coherent notion of space in physics where things can for example move without being âshreddedâ, so also this will happen in mathematics. And this is why itâs possible to do âhigherlevel mathematicsâ without always dropping down to the lowest level of axiomatic derivations.
Itâs worth pointing out that even in physical space a concept like âpure motionâ in which objects can move while maintaining their identity doesnât always work. For example, close to a spacetime singularity, one can expect to eventually be forced to see through to the discrete structure of spaceâand for any âobjectâ to inevitably be âshreddedâ. But most of the time itâs possible for observers like us to maintain the idea that there are coherent largescale features whose behavior we can study using âbulkâ laws of physics.
And we can expect the same kind of thing to happen with mathematics. Later on, weâll discuss more specific correspondences between phenomena in physics and mathematicsâand weâll see the effects of things like general relativity and quantum mechanics in mathematics, or, more precisely, in metamathematics.
But for now, the key point is that we can think of mathematics as somehow being made of exactly the same stuff as physics: theyâre both just features of the ruliad, as sampled by observers like us. And in what follows weâll see the great power that arises from using this to combine the achievements and intuitions of physics and mathematicsâand how this lets us think about new âgeneral laws of mathematicsâ, and view the ultimate foundations of mathematics in a different light.
Consider all the mathematical statements that have appeared in mathematical books and papers. We can view these in some sense as the âobserved phenomenaâ of (human) mathematics. And if weâre going to make a âgeneral theory of mathematicsâ a first step is to do something like weâd typically do in natural science, and try to âdrill downâ to find a uniform underlying modelâor at least representationâfor all of them.
At the outset, it might not be clear what sort of representation could possibly capture all those different mathematical statements. But whatâs emerged over the past century or soâwith particular clarity in Mathematica and the Wolfram Languageâis that there is in fact a rather simple and general representation that works remarkably well: a representation in which everything is a symbolic expression.
One can view a symbolic expression such as f[g[x][y, h[z]], w] as a hierarchical or tree structure, in which at every level some particular âheadâ (like f) is âapplied toâ one or more arguments. Often in practice one deals with expressions in which the heads have âknown meaningsââas in Times[Plus[2, 3], 4] in Wolfram Language. And with this kind of setup symbolic expressions are reminiscent of human natural language, with the heads basically corresponding to âknown wordsâ in the language.
And presumably itâs this familiarity from human natural language thatâs caused âhuman natural mathematicsâ to develop in a way that can so readily be represented by symbolic expressions.
But in typical mathematics thereâs an important wrinkle. One often wants to make statements not just about particular things but about whole classes of things. And itâs common to then just declare that some of the âsymbolsâ (like, say, x) that appear in an expression are âvariablesâ, while others (like, say, Plus) are not. But in our effort to capture the essence of mathematics as uniformly as possible it seems much better to burn the idea of an object representing a whole class of things right into the structure of the symbolic expression.
And indeed this is a core idea in the Wolfram Language, where something like x or f is just a âsymbol that stands for itselfâ, while x_ is a pattern (named x) that can stand for anything. (More precisely, _ on its own is what stands for âanythingâ, and x_âwhich can also be written x:_âjust says that whatever _ stands for in a particular instance will be called x.)
Then with this notation an example of a âmathematical statementâ might be:
✕

In more explicit form we could write this as Equal[f[x_, y_], f[f[y_, x_],y_]]—where Equal () has the âknown meaningâ of representing equality. But what can we do with this statement? At a âmathematical levelâ the statement asserts that and should be considered equivalent. But thinking in terms of symbolic expressions thereâs now a more explicit, lowerlevel, âstructuralâ interpretation: that any expression whose structure matches can equivalently be replaced by (or, in Wolfram Language notation, just (y â x) â y) and vice versa. We can indicate this interpretation using the notation
✕

which can be viewed as a shorthand for the pair of Wolfram Language rules:
✕

OK, so letâs say we have the expression . Now we can just apply the rules defined by our statement. Hereâs what happens if we do this just once in all possible ways:
✕

And here we see, for example, that can be transformed to . Continuing this we build up a whole multiway graph. After just one more step we get:
