Before Turing machines, before lambda calculus—even before Gödel’s theorem—there were combinators. They were the very first abstract examples ever to be constructed of what we now know as universal computation—and they were first presented on December 7, 1920. In an alternative version of history our whole computing infrastructure might have been built on them. But as it is, for a century, they have remained for the most part a kind of curiosity—and a pinnacle of abstraction, and obscurity.

]]>Before Turing machines, before lambda calculus—even before Gödel’s theorem—there were combinators. They were the very first abstract examples ever to be constructed of what we now know as universal computation—and they were first presented on December 7, 1920. In an alternative version of history our whole computing infrastructure might have been built on them. But as it is, for a century, they have remained for the most part a kind of curiosity—and a pinnacle of abstraction, and obscurity.

]]>There are claims made in the Wolfram Physics Project about the equivalence of confluence and causal invariance. This bulletin demonstrates that some of these claims are not correct. For example, consider the glossary on the project’s website, which as of October 30, 2020, says:

**Causal Invariance:** A property of multiway graphs whereby all possible paths yield the isomorphic causal graphs. When causal invariance exists, every branch in the multiway system must eventually merge. Causal invariance is a core property associated with relativistic invariance, quantum objectivity, etc. In the theory of term rewriting, a closely related property is confluence. In a terminating system, causal invariance implies that whatever path is taken, the “answer” will always be the same.

**Confluence:** A simplified form of causal invariance considered in term rewriting systems such as ones that reach fixed points.

However, the glossary does not explicitly define confluence, so we are going to use the standard definition from the theory of rewriting systems:

A state *a* is deemed confluent if, for all pairs of states *b*, *c* that can be reached from *a*, there exists a state *d* that can be reached from both *b* and *c*. If every state in the system is confluent, the system itself is confluent.

We can summarize the statements above with the following definitions:

A Wolfram model evolution is called **causal invariant** if and only if the causal graphs for singleway evolutions with any possible event ordering functions are isomorphic.

Note that the definition above is only meaningful for terminating systems (i.e. the systems that always reach a `"FixedPoint"`, a state during the evolution where no more matches can be made to its expressions).

We can then define confluence as:

A Wolfram model evolution is called *confluent* if and only if any pair of partial singleway evolutions starting from a particular state can be continued in such a way as to reach isomorphic final states.

In what follows, we will demonstrate that causal invariance is *not* equivalent to confluence, neither of them implies the other, and the two statements made above are false:

When causal invariance exists, every branch in the multiway system must eventually merge.

In a terminating system, causal invariance implies that whatever path is taken, the “answer” will always be the same.

We will not make any comments in this note about the physics claims made above.

Before we get to specific examples, it’s essential to understand the fundamental difference between these two properties. *Causal invariance* has to do with symmetries between evolution branches of expressions-events graphs. It requires that, even though the branches operate on different expressions, they have the same causal structure:

On the other hand, *confluence* has to do with the symmetries between expressions’ contents. It requires that particular states from different branches are isomorphic as hypergraphs, regardless of the causal structures that lead to them:

Consider the following system:

✕
confluentRule = {{1}, {1, 2}} -> {{1, 2}, {2}}; confluentInit = {{1}, {1, 2}, {2, 3}, {1, 3}}; |

This system is confluent, as any partial evolution, if continued, will always terminate at the final state isomorphic to {{1, 2}, {2, 3}, {1, 3}, {3}}:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {confluentRule}, {confluentInit}, 2, "StatesGraph", VertexSize -> 1] |

However, this system is not causal invariant. We can generate two non-isomorphic causal graphs by using different event ordering functions, which contradicts the definition above:

✕
IsomorphicGraphQ @@ Echo@(WolframModel[confluentRule, confluentInit, Infinity, "EventOrderingFunction" -> #][ "CausalGraph"] & /@ {"OldestEdge", "NewestEdge"}) |

Therefore, confluence *does not imply* causal invariance.

Note that the `"CausalInvariantQ"` property of `MultiwaySystem` checks for confluence despite its name:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {confluentRule}, {confluentInit}, 2, \ "CausalInvariantQ"] |

Consider the following causal invariant system:

✕
causalInvariantRule = {{1, 2}, {2, 1}} -> {{1}}; causalInvariantInit = {{1, 2}, {2, 1}, {1}}; |

To see that it’s causal invariant, note that the multiway system in this case only has two events:

✕
WolframModel[causalInvariantRule, causalInvariantInit, Infinity, "EventSelectionFunction" -> "MultiwaySpacelike"]["ExpressionsEventsGraph", VertexLabels -> Automatic] |

These two events correspond to two different singleway evolutions terminating at states {{1}, {1}} and {{1}, {2}}, respectively:

✕
WolframModel[causalInvariantRule, causalInvariantInit, Infinity, "EventOrderingFunction" -> #]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]] & /@ {"RuleOrdering", "ReverseRuleOrdering"} |

These evolutions yield isomorphic causal graphs, which are composed of a single vertex with no edges, implying that this system is causal invariant by definition:

✕
IsomorphicGraphQ @@ Echo@(WolframModel[causalInvariantRule, causalInvariantInit, Infinity, "EventOrderingFunction" -> #][ "CausalGraph"] & /@ {"RuleOrdering", "ReverseRuleOrdering"}) |

It is not, however, confluent, because the final states in these two evolutions are not isomorphic, and the evolutions terminate after these states are reached:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {causalInvariantRule}, {causalInvariantInit}, 2, \ "StatesGraph", VertexSize -> .7] |

Therefore, causal invariance *does not imply* confluence.

Note that the `"CausalInvariantQ"` property of `MultiwaySystem` returns `False` in this case:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {causalInvariantRule}, {causalInvariantInit}, 2, \ "CausalInvariantQ"] |

It would be interesting to investigate the systems exhibiting these properties in different combinations. For example, systems that don’t exhibit multiway branching at all do satisfy both of these conditions. One can also consider systems in which causal-graphs isomorphism is equivalent to states isomorphism by construction—for example, classical sequential growth models of causal sets. It might be possible to generalize this to include more classes of systems. We could also enumerate (#57) simple rules and determine how many of them exhibit just one of these properties, both or neither.

To do that, we need to implement tests for both confluence (#59, #477) and causal invariance (#486) in *SetReplace*.

We will also need to generalize the definition of causal invariance to non-terminating Wolfram models (#487).

It will be interesting to investigate other similar properties. For example, one can investigate a stronger version of confluence:

- Consider any infinite singleway evolution of a system.
- Consider another finite partial singleway evolution.
- If any such finite evolution can be continued in such a way as to reach one of the states from the infinite evolution, we define the system as
*“super”-confluent*(#478).

This note introduces local multiway systems and examines them in the context of the singleway and global multiway systems.

By default, `WolframModel` computes only a single branch of the evolution. If there are multiple matches of the rules to the hypergraph, only one of these matches will be turned into an actualized event, and the other matches will be ignored. They will not appear in the evolution object.

This, however, introduces a dependence on the evaluation order, which might not be desirable if one’s goal is to eliminate arbitrariness from the system.

There are multiple possible resolutions to this problem. One is to only consider causal invariant rules, i.e. the rules with a property such that the result of the evolution does not depend on the event order. This is, however, quite limiting, as we will be ignoring the majority of the rules. Also, the idea of having multiple possible evolution paths is, in itself, interesting to investigate.

Another approach is to consider the so-called multiway systems, which evaluate all possible ways to resolve such overlaps between matches. This is the approach that is discussed in this note.

The original type of the multiway system that was first considered in the Wolfram Physics Project is what we will call the *global* multiway system, which will be discussed in more detail in the next section. Here we propose a new kind of multiway system, called a *local* multiway system. The prime difference is that it allows one to consider the branching of only parts of space (subgraphs of the state hypergraph) instead of the entire hypergraph all at once.

In the subsequent sections, we will discuss the local multiway system in more detail and introduce the types of relationships possible between expressions produced during its evolution.

The most important thing to understand about the global multiway system is that it operates on entire states. The most fundamental object is the states graph, which has states at the vertices and updating events at the edges. All possible updating events are determined for each state, and edges leading to new states are created. This process is then repeated for the new states.

Let’s consider an instance of the global multiway system (implemented in the `MultiwaySystem` resource function). Specifically, let’s start with a rule that moves a “particle” (a unary expression) along directed edges in a graph:

✕
RulePlot[WolframModel[{{1}, {1, 2}} -> {{1, 2}, {2}}]] |

If we run this system on a path graph with three vertices, we get a very simple behavior:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {{{1}, {1, 2}} -> {{1, 2}, {2}}}, {{{1}, {1, 2}, {2, 3}}}, 3, "StatesGraph", VertexSize -> 1] |

Now, what happens if we split the path in this graph into two different branches? In this case, the rules will lead to non-deterministic behavior—multiple choices of substitutions are possible—so the system explores all possible choices at once:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {{{1}, {1, 2}} -> {{1, 2}, {2}}}, {{{1}, {1, 2}, {2, 3}, {2, 4}, {4, 5}}}, 4, "StatesGraph", Sequence[ VertexSize -> 1, GraphLayout -> "LayeredDigraphEmbedding"]] |

Now the states graph itself splits into two branches, mirroring precisely the input graph.

One important feature of `MultiwaySystem` is that if it encounters multiple states that are isomorphic, it merges them into one. For example, if instead of the input graph in the example above we use the graph where the branches have the same length, the system will combine them, and we will not see the splitting behavior:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {{{1}, {1, 2}} -> {{1, 2}, {2}}}, {{{1}, {1, 2}, {2, 3}, {3, 4}, {2, 5}, {5, 6}}}, 3, "StatesGraph", Sequence[ VertexSize -> 1, GraphLayout -> "LayeredDigraphEmbedding"]] |

This is why our original graph uses branches of different lengths ({{2, 3}} and {{2, 4}, {4, 5}}).

But what if we start with particles on different branches and let them merge?

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {{{1}, {1, 2}} -> {{1, 2}, {2}}}, {{{a1}, {a1, a2}, {a2, a3}, {a3, m1}, {b1}, {b1, b2}, {b2, m1}, {m1, m2}}}, 7, "StatesGraph", Sequence[ VertexSize -> {1.6, 0.32}, GraphLayout -> "LayeredDigraphEmbedding", EdgeStyle -> Automatic, GraphHighlight -> {{{1}, {2}, {1, 3}, {2, 4}, {3, 5}, {4, 6}, {5, 6}, {6, 7}} -> {{1}, {2}, {1, 3}, {2, 4}, {3, 5}, {4, 5}, {5, 6}, {7, 1}}, {{1}, {2}, {1, 3}, {2, 4}, {3, 5}, {5, 4}, {4, 6}, {7, 2}} -> {{1}, {2}, {1, 3}, {2, 4}, {3, 4}, {4, 5}, {6, 1}, {7, 2}}}]] |

Note that even at the first step, the system branches in two different states. However, there is no ambiguity. The two events there occur at entirely different places in space. Note also that some events are duplicated. For example, the two events highlighted red are the same event, as they both correspond to the particle on a more extended branch moving one step.

So, based on the above, there are two issues with the global multiway system.

First, there is an incredible amount of redundancy. In particular, if there is an event that happened somewhere in a faraway galaxy, it would mean the entire universe, including all of the expressions here on Earth, duplicates, which seems both strange and unnecessary, and is fundamentally non-local. In other words, there is exponentially more data in the global multiway system than is necessary to describe the state of the universe completely.

Second, it is hard to distinguish between space evolving in disconnected regions in parallel (i.e. spacelike events) and multiway branching due to overlapping event inputs (i.e. branchlike events).

In the global multiway system, these look identical. The only way to distinguish them is to examine their input and output states, which is a highly nontrivial problem, especially given that both states are canonicalized.

To illustrate the point, here is an example of a branchlike- and a spacelike-separated pair of events, respectively:

✕
ResourceFunction["MultiwaySystem"]["WolframModel" -> #1, {#2}, 2, "StatesGraph", Sequence[ VertexSize -> {1.6, 0.32}, GraphLayout -> "LayeredDigraphEmbedding", EdgeStyle -> Automatic]] & @@@ {{{{{1, 2}, {2, 3}} -> {{1, 2, 3}}, {{1, 2, 3}} -> {{1, 3}}}, {{1, 2}, {2, 3}, {3, 4}}}, {{{{1, 2}} -> {{1, 2, 3}}}, {{1, 2}, {2, 3}}}} |

Let us then consider a different approach. Suppose we have a system with overlapping pairs of rule matches. We still want to include all of those events in the multiway system. But instead of duplicating the entire state, we will do that locally; i.e. we will have multiple branches growing from that pair of events, and we will weave them into a single data structure describing the entire multiway system. The states themselves will then be reconstructed afterward in post-processing.

This approach sounds complicated at first, but it is more straightforward than it appears. To understand how it would work, let’s think first about how one would implement a singleway Wolfram model evolution.

In our implementation, the data structure is simply a set of expressions, and each expression has information about events that have created and destroyed it:

✕
{<|"Atoms" -> {atom1, atom2, ...}, "CreatorEvent" -> eventIndex, "DestroyerEvent" -> eventIndex|>, ...} |

The collection of these objects is essentially the only thing that needs to be returned from the evolution code. Things like `"StatesList"` and `"CausalGraph"` can be reconstructed.

The causal graph, in particular, is the simplest one to reconstruct. Indeed, if each event is a vertex, and each expression is an edge going from its `#CreatorEvent` to its `#DestroyerEvent`, that would immediately give us a causal graph.

Reconstructing states is a bit more complicated, but it can be done by selecting a foliation of a causal graph, i.e. a subset of events including all of their dependencies, and selecting all expressions that were created but not destroyed by one of those events.

In addition to this data structure, we need to have an index of matches. It’s a set of all possible matches that can be made to the current state, and it is updated after each event is applied.

It is initially created at the construction of the system by indexing the initial condition. Each event’s outputs are then indexed after its instantiation (potentially by matching those outputs with their neighbors). The matches that involve the input expressions are deleted from the index, and the expressions themselves are not allowed to be used in further matching.

This deletion causes the system to be singleway, as once an expression is used in an event, it can never be matched again. It is also the reason there is only one destroyer event for each expression.

However, imagine that instead of deleting all matches involving the input expressions, we will only remove the instantiated match. With only that change, we will evolve the system precisely the same way we used to.

Note, in this case, we will automatically get a multiway system—in fact, the match-all version of it. It is called match-all because it will match not only the spacelike sets of expressions but also branchlike and even timelike ones.

To understand what it means, let’s try some examples. Even the most trivial rules become too complicated quite quickly in the match-all system, so let’s use the pattern rules with globally named atoms here. We will be using the `"ExpressionsEventsGraph"` property of the `WolframModel`, which will allow us to see both expressions and events on the same graph.

Let’s then take a look at the following system:

✕
WolframModel[<| "PatternRules" -> {{{1, 2}} -> {{2, 3}}, {{1, 2}, {2, 3}} -> {{1, 2, 3}}}|>, {{1, 2}}, Infinity, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]] |

In this case we have two rules, {{1, 2}} → {{2, 3}} and {{1, 2}, {2, 3}} → {{1, 2, 3}}. Note that here 1, 2 and 3 are not patterns but labeled vertices. We have started with an initial condition, which is a single expression {1, 2}. We have obtained two events.

The first event replaced {1, 2} with {2, 3}. That is entirely normal and would happen in a singleway system as well. However, the singleway system would terminate immediately after that, as there is only a single expression {2, 3} left now, {1, 2} has been deleted and the second rule requires both {1, 2} and {2, 3} as inputs. In other words, {1, 2} and {2, 3} are *timelike* expressions, and our singleway `WolframModel` only matches *spacelike* expressions.

However, the match-all multiway system will proceed, as both {1, 2} and {2, 3} are now in the system, and it does not care that they are timelike. Hence, the second event is instantiated as well, {{1, 2}, {2, 3}} → {{1, 2, 3}}. Note that at the end of this evolution, all three expressions {1, 2}, {2, 3} and {1, 2, 3} are open for further matching, and the only reason further matching does not occur is because both possible exact matches have already been instantiated.

If, however, we add another rule, {{1, 2}, {1, 2, 3}} → {{2, 3}}, the system will keep evolving indefinitely, as {2, 3} created after applying the new rule is not the same {2, 3} as was created by the first rule. Therefore, it will be matched again by the second rule. After that, the second and third rules will keep “oscillating”, supplying inputs to one another:

✕
WolframModel[<| "PatternRules" -> {{{1, 2}} -> {{2, 3}}, {{1, 2}, {2, 3}} -> {{1, 2, 3}}, {{1, 2}, {1, 2, 3}} -> {{2, 3}}}|>, {{1, 2}}, 6, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, Before]] |

The match-all system will match branchlike events as well, as can be seen in the following example:

✕
WolframModel[<| "PatternRules" -> {{{1, 2}} -> {{2, 3}}, {{1, 2}} -> {{2, 4}}, {{2, 3}, {2, 4}} -> {{2, 3, 4}}}|>, {{1, 2}}, 6, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]] |

Note in the above there are two possibilities to match {{1, 2}}, which are incompatible according to the ordinary `WolframModel` and can only be achieved one at a time with different choices of the `"EventOrderingFunction"`. However, the match-all system can still match the two outputs with the third rule.

Further note the obvious feature of the match-all system: it produces expressions and events that would occur in neither the singleway `WolframModel` nor the global `MultiwaySystem`. As such, it is a form of “interference” between branches and might allow branches to merge and interact.

Reconstructing causal graphs in this system is straightforward as well. In fact, all one needs to do is to allow multiple destroyer events:

✕
{<|"Atoms" -> {atom1, atom2, ...}, "CreatorEvent" -> eventIndex, "DestroyerEvents" -> {eventIndex1, eventIndex2, ...}|>, ...} |

Now, each expression would correspond to exactly `Length[#DestroyerEvents]` causal edges, with each one going from the `#CreatorEvent` to each element of the `#DestroyerEvents`. An even more useful structure is the expressions-events graph already used above, where both events and expressions are represented as differently colored vertices. There is only one edge going into each expression-vertex (corresponding to its `#CreatorEvent`). And there are `Length[#DestroyerEvents]` edges coming out of each expression-vertex. This immediately lets us see the locations where the true multiway branching occurs.

For example, the pair of systems demonstrated above where the separation was hard to distinguish in the global multiway system now looks like this:

✕
WolframModel[#1, #2, 2, "EventSelectionFunction" -> None][ "ExpressionsEventsGraph", VertexLabels -> Placed[ Automatic, After]] & @@@ {{{{{1, 2}, {2, 3}} -> {{1, 2, 3}}, {{1, 2, 3}} -> {{1, 3}}}, {{1, 2}, {2, 3}, {3, 4}}}, {{{1, 2}} -> {{1, 2, 3}}, {{1, 2}, {2, 3}}}} // Map[ Framed[#, FrameStyle -> LightGray]& , #] & |

Note that the vertex {2, 3} in the first example has an out-degree of 2, which indicates the multiway branching. Also note that the second example’s events are entirely disconnected, as there are no causal connections between them. In addition, there are only two events instead of four, as the local multiway system does not duplicate identical events.

The reconstruction of spatial states is more complicated. However, it is still relatively straightforward to understand how a local patch of space would look. Indeed, what is space? Ultimately, it’s a collection of expressions that are all pairwise spacelike separated with one another. And indeed, we can create such patches in a match-all system just like in any other system.

However, we need to discuss in more detail what it means for the two events or expressions to be spacelike, branchlike or timelike.

Suppose we want to have more control over the local multiway system’s matching behavior and reproduce the global multiway system’s evolution. In that case, we need a way to detect whether a pair of expressions is:

- Spacelike — the expressions were produced (directly or indirectly) by a single event
- Branchlike — the expressions were made (directly or indirectly) by multiple events that matched the same expression
- Timelike — the expressions are causally related: one produced or was produced by another

And in simple systems, it is straightforward to understand what the separation is, i.e. in the following three systems, the expressions {2, 3} and {3, 4} are spacelike, branchlike and timelike, respectively:

✕
Framed[WolframModel[<|"PatternRules" -> #|>, {{1, 2}}, Infinity, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]], FrameStyle -> LightGray] & /@ {{{1, 2}} -> {{2, 3}, {3, 4}}, {{{1, 2}} -> {{2, 3}}, {{1, 2}} -> {{3, 4}}}, {{{1, 2}} -> {{2, 3}}, {{2, 3}} -> {{3, 4}}}} |

In the first example, a single event produces two expressions, {2, 3} *and* {3, 4}. This corresponds to a spacelike separation, as both of these expressions can appear simultaneously in a singleway system. In the second example, there are two possibilities: the first or the second rule can be matched to the initial expression {1, 2}. Hence, the expressions produced from that, {2, 3} and {3, 4}, are branchlike separated. Finally, in the third example, evolution is linear. The first event and the expression {2, 3} are the prerequisites for the second event and the expression {3, 4}. Hence, these expressions are timelike separated.

So, if the expressions are immediate neighbors in the causal graph, as in the examples above, the separation is not hard to determine. However, what if the expressions are further back in history?

For example, what about the expressions {4, 5} and {5, 6} here?

✕
WolframModel[<| "PatternRules" -> {{{1, 2}} -> {{2, 3}}, {{1, 2}} -> {{3, 4}}, {{2, 3}, {3, 4}} -> {{4, 5}, {5, 6}}}|>, {{1, 2}}, Infinity, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]] |

In this example, the expression {1, 2} first branches into two expressions {2, 3} and {3, 4}. They are then merged by the third event, which creates two expressions, {4, 5} and {5, 6}. In that case, the final expressions {4, 5} and {5, 6} would still be spacelike separated, as they were produced from a single event after the branches have already merged.

But what about something like this?

✕
WolframModel[<| "PatternRules" -> {{{v, i}} -> {{v, 1}, {v, 2}}, {{v, 1}} -> {{v, 1, 1}, {v, 1, 2}}, {{v, 1, 1}, {v, 2}} -> {{v, f, 1}}, {{v, 1, 2}, {v, 2}} -> {{v, f, 2}}}|>, {{v, i}}, Infinity, "EventSelectionFunction" -> None]["ExpressionsEventsGraph", VertexLabels -> Placed[Automatic, After]] |

What is the separation between the expressions {*v*, *f*, 1} and {*v*, *f*, 2}? On one hand, they are spacelike separated, because one of their common ancestors is the event {{*v*, 1}} → {{*v*, 1, 1}, {*v*, 1, 2}}. But on the other hand, they are branchlike separated, as they have an expression {*v*, 2} as another common ancestor. In other words, these expressions are mixed spacelike and branchlike separated. And if we had an event matching both {*v*, *f*, 1} and {*v*, *f*, 2} as inputs, it would simultaneously merge different pieces of space and two different branches.

It seems, however, that the branchial separation should take precedence. That is because if we only allow events to match spacelike-separated expressions, we expect the evolution to be equivalent to the global multiway system evolution. In this case, we have to define the separation above as branchlike, as the two final expressions can never simultaneously appear in the same singleway system.

Thus, to determine the separation between two expressions, A and B, in an expressions-events graph:

- Compute the past causal cones of both A and B.
- Compute the intersection between the causal cones.
- Take all vertices with out-degree zero (the future boundary of the intersection):

— If the boundary contains either A or B, they are timelike separated.

— If any vertices on the boundary are expression-vertices, they are branchlike separated.

— Otherwise, all vertices on the boundary are event-vertices, and they are spacelike separated.

Now that we understand how to precisely define separations between expressions, we can make a spacelike-only multiway system, i.e. a system that would only match pairwise spacelike groups of expressions, similar to what the global `MultiwaySystem` does.

Indeed, all we need for that case is a verification that an event we are about to instantiate does not merge branches.

The only modification we need to do compared to the match-all system is adding matches to the index only if their inputs are pairwise spacelike separated. The expressions we will get then will be exactly the same as in the global `MultiwaySystem`.

It is interesting now to consider the same example of two particles starting on two different branches that caused lots of redundancy in the global `MultiwaySystem`.

As a reminder, the system evaluates the propagation of two “particles” along a directed graph:

✕
WolframModelPlot[{{a1}, {a1, a2}, {a2, a3}, {a3, m1}, {b1}, {b1, b2}, {b2, m1}, {m1, m2}}, VertexLabels -> Automatic] |

Instead of a mesh of redundant events that the global multiway system produced, we now only have two places where the events merge:

✕
WolframModel[{{1}, {1, 2}} -> {{1, 2}, {2}}, {{a1}, {a1, a2}, {a2, a3}, {a3, m1}, {b1}, {b1, b2}, {b2, m1}, {m1, m2}}, Infinity, "EventSelectionFunction" -> "MultiwaySpacelike"]["ExpressionsEventsGraph", Sequence[ VertexLabels -> Automatic, ImageSize -> 400]] |

It is perhaps easier to see in a different layout:

✕
WolframModel[{{1}, {1, 2}} -> {{1, 2}, {2}}, {{a1}, {a1, a2}, {a2, a3}, {a3, m1}, {b1}, {b1, b2}, {b2, m1}, {m1, m2}}, Infinity, "EventSelectionFunction" -> "MultiwaySpacelike"]["ExpressionsEventsGraph", Sequence[ VertexLabels -> Automatic, GraphLayout -> "SpringElectricalEmbedding", ImageSize -> 600]] |

If we look closely at the events near the merge points, we can see that some redundancy remains. However, it is no longer due to the spacelike-separated events, but rather due to the “background” expressions being rewritten during evolution. And as a result, if a particle follows another particle on the same “track”, the expressions it’s going through are different (even though they involve the same vertices), hence the duplication.

Note that all branches are entirely independent in this kind of evolution, and they simply reproduce all possible evolution orders in singleway systems.

Some further improvements and features can be implemented and investigated.

We can consider multiway systems that are neither match-all nor spacelike. For example, one possibility would be to allow branchlike but not timelike matching. We can even consider hybrid systems where some of the rules are spacelike and some branchlike. The progress of that direction is tracked in *SetReplace* issues #345 and #346.

Another direction to consider is the deduplication of expressions. The global `MultiwaySystem` canonicalizes and deduplicates every state it encounters; thus, for example, the final state {1, 2, 3, 4} here only appears once:

✕
ResourceFunction["MultiwaySystem"][ "WolframModel" -> {{{1}} -> {{1, 2, 3}}, {{1, 2, 3}} -> {{1, 2}, {1, 3}}, {{1}} -> {{1, 2}, {1, 3}}, {{1, 2}, {1, 3}} -> {{1, 2, 3, 4}}}, {{{1}}}, 2, "StatesGraph", Sequence[ VertexSize -> {1.6, 0.32}, GraphLayout -> "LayeredDigraphEmbedding", EdgeStyle -> Automatic]] |

The current implementation of the local multiway system does not do that, however:

✕
WolframModel[{{{1}} -> {{1, 2, 3}}, {{1, 2, 3}} -> {{1, 2}, {1, 3}}, {{1}} -> {{1, 2}, {1, 3}}, {{1, 2}, {1, 3}} -> {{1, 2, 3, 4}}}, {{1}}, Infinity, "EventSelectionFunction" -> "MultiwaySpacelike"]["ExpressionsEventsGraph", VertexLabels -> Automatic] |

It would be interesting to introduce isomorphism testing to the local multiway system, as it will allow for a much better understanding of how branches combine at the local level. This isomorphism testing can be done by starting with a subset of spacelike-separated expressions. We can then consider a pair of singleway evolutions starting from these expressions (events in them will be subsets of the entire multiway evolution). Let’s then consider the final states of these spacelike evolutions. Suppose they are identical up to the renaming of new atoms. In that case, we can deduplicate the resulting expressions so that the two branches corresponding to singleway evolutions end at the same set of expressions, even if the intermediate steps are different.

In the example above, we can consider two evolutions starting from {{1}} and ending at {{1, 4}, {1, 5}} and {{1, 2}, {1, 3}}, respectively. Note that if we rename {4 → 2, 5 → 3}, the final states become identical. Hence, we can deduplicate them, merging future evolutions (since they now start from the same set of expressions). We then get:

✕
Graph[{{1} -> 1, {1} -> 2, 1 -> {1, 2, 3}, {1, 2, 3} -> 3, 2 -> {1, 2}, 2 -> {1, 3}, 3 -> {1, 2}, 3 -> {1, 3}, {1, 2} -> 4, {1, 2} -> 5, {1, 3} -> 4, {1, 3} -> 5, 4 -> {1, 2, 3, 4}, 5 -> {1, 3, 2, 4}}, Sequence[ EdgeStyle -> SetReplace`WolframPhysicsProjectStyleData[ "ExpressionsEventsGraph", "EdgeStyle"], VertexLabels -> Prepend[Automatic][ Apply[# -> StringJoin["Rule ", ToString[#2]]& , {{1, 1}, {2, 3}, {3, 2}, {4, 4}, {5, 4}}, {1}]], VertexStyle -> Apply[# -> SetReplace`WolframPhysicsProjectStyleData[ "ExpressionsEventsGraph", #2]& , {{{ BlankSequence[Integer]}, "ExpressionVertexStyle"}, { Blank[Integer], "EventVertexStyle"}}, {1}]]] |

However, looking at even this simple example, we can determine that the algorithm described above is not quite right; e.g. consider the last two expressions, {1, 2, 3, 4} and {1, 3, 2, 4}. On the one hand, if we start all the way from {{1}} and consider two possible evolutions ending with {{1, 2, 3, 4}} and {{1, 3, 2, 4}}, they should be deduplicated, as they are the same up to the renaming 2 ↔ 3. However, if one was to deduplicate them, one of the events corresponding to rule 4 will be incorrectly instantiated, as it will match the inputs in the order {{1, 3}, {1, 2}} but will name the outputs as if they were matched in the order {{1, 2}, {1, 3}}.

But if there is a consistent way to define it, this approach will be the most compact representation of a multiway system so far. It will allow us to see the internal structure of the global multiway system evolution, which is currently inaccessible. The implementation is tracked in the *SetReplace* issue #349.

“So you think you have a fundamental theory of physics. Well, then tell us if warp drive is possible!” Despite the hopes and assumptions of science fiction, real physics has for at least a century almost universally assumed that no genuine effect can ever propagate through physical space any faster than light. But is this actually true? We’re now in a position to analyze this in the context of our model for fundamental physics. And I’ll say at the outset that it’s a subtle and complicated question, and I don’t know the full answer yet.

But I increasingly suspect that going faster than light is not a physical impossibility; instead, in a sense, doing it is “just” an engineering problem. But it may well be an irreducibly hard engineering problem. And one that can’t be solved with the computational resources available to us in our universe. But it’s also conceivable that there may be some clever “engineering solution”, as there have been to so many seemingly insuperable engineering problems in the past. And that in fact there is a way to “move through space” faster than light.]]>
*When the **NASA Innovative Advanced Concepts Program** asked me to keynote their annual conference I thought it would be a good excuse to spend some time on a question that I’ve always thought would be interesting to explore...*

“So you think you have a fundamental theory of physics. Well, then tell us if warp drive is possible!” Despite the hopes and assumptions of science fiction, real physics has for at least a century almost universally assumed that no genuine effect can ever propagate through physical space any faster than light. But is this actually true? We’re now in a position to analyze this in the context of our model for fundamental physics. And I’ll say at the outset that it’s a subtle and complicated question, and I don’t know the full answer yet.

But I increasingly suspect that going faster than light is not a physical impossibility; instead, in a sense, doing it is “just” an engineering problem. But it may well be an irreducibly hard engineering problem. And one that can’t be solved with the computational resources available to us in our universe. But it’s also conceivable that there may be some clever “engineering solution”, as there have been to so many seemingly insuperable engineering problems in the past. And that in fact there is a way to “move through space” faster than light.]]>

One of the many surprising things about our Wolfram Physics Project is that it seems to have implications even beyond physics. In our effort to develop a fundamental theory of physics it seems as if the tower of ideas and formalism that we've ended up inventing are actually quite general, and potentially applicable to all sorts of areas.

One area about which I've been particularly excited of late is metamathematics—where it's looking as if it may be possible to use our formalism to make what might be thought of as a “bulk theory of metamathematics”.

Mathematics itself is about what we establish about mathematical systems. Metamathematics is about the infrastructure of how we get there—the structure of proofs, the network of theorems, and so on. And what I'm hoping is that we're going to be able to make an overall theory of how that has to work: a formal theory of the large-scale structure of metamathematics—that, among other things, can make statements about the general properties of “metamathematical space”.]]>

One of the many surprising things about our Wolfram Physics Project is that it seems to have implications even beyond physics. In our effort to develop a fundamental theory of physics it seems as if the tower of ideas and formalism that we've ended up inventing are actually quite general, and potentially applicable to all sorts of areas.

One area about which I've been particularly excited of late is metamathematics—where it's looking as if it may be possible to use our formalism to make what might be thought of as a “bulk theory of metamathematics”.

Mathematics itself is about what we establish about mathematical systems. Metamathematics is about the infrastructure of how we get there—the structure of proofs, the network of theorems, and so on. And what I'm hoping is that we're going to be able to make an overall theory of how that has to work: a formal theory of the large-scale structure of metamathematics—that, among other things, can make statements about the general properties of “metamathematical space”.]]>

This bulletin is a short note detailing how single-slit, double-slit and multi-slit photon diffraction and interference patterns can be successfully reproduced using the author’s own formulation of quantum mechanics in the Wolfram model. The author has benefited greatly from many fruitful conversations with Stephen Wolfram, as well as from the encouragement (and infectious enthusiasm) of Hatem Elshatlawy.

When we announced the Wolfram Physics Project back in April, among the many launch documents that Stephen and I wrote was a paper in which I outlined a mathematical formulation of quantum mechanics in the Wolfram model in terms of multiway systems, path weights and completion procedures, and presented rigorous derivations of several key features of conventional quantum mechanical formalism, including the canonical commutation relations, the path integral and the Schrödinger equation. It even conjectured a precise algorithmic procedure by which one could describe the otherwise mysterious phenomenon of “wavefunction collapse” in the context of quantum measurement. It constituted a natural supplement to Stephen’s less mathematical (and correspondingly much more accessible) technical introduction to our quantum mechanical formalism. I outlined in great detail how quantum amplitudes would emerge as a consequence of path weights in the multiway evolution graph, with phase differences between pairs of paths thus corresponding to the ratios of branchlike- to spacelike-separated events, in such a way that applying an appropriate Knuth–Bendix completion procedure to the multiway system would force the analog of both constructive and destructive interference between different branches of history, exactly as conventional quantum mechanics predicts.

Since many of the key “classic” phenomena of quantum mechanics, such as the diffraction and interference of photons passing through parallel slits, are ultimately just elementary corollaries of this derivation of the Schrödinger equation, I fully expected that very soon after the release of my paper, somebody out there would take the requisite couple of minutes to sit down and write the trivial piece of code needed to reproduce the famous double-slit experiment in the Wolfram model. Following Stephen’s earnest advice to me about how best to instigate a new research program (“You mustn’t pick all the low-hanging fruit yourself! Leave something for the new people to do!”), I had explicitly decided to leave this particularly juicy-looking piece of fruit unpicked, hoping that some young student would come along and be the first to see the interference fringes for themselves. Several months went by, and despite my continued encouragement to various people (including several students at our Summer School!), for whatever reason, nobody did the experiment. So, in the end, I decided that I would just do it myself over a spare weekend, and this short bulletin was the result.

The first part of this bulletin demonstrates how, using only a simple string multiway system equipped with elementary path weights, one can easily reproduce the known phenomena of single-slit, double-slit and multi-slit photon interference, yielding intensity patterns that can be shown to converge to the results predicted analytically by the standard equations of optics/quantum mechanics, and indicates how these interference patterns connect to the geometry of branchial space (and hence to the geometry of the associated projective Hilbert space of the system). The second part then illustrates precisely why these interference patterns appear, as a straightforward consequence of the basic combinatorics of multiway systems and some elementary number theory; it demonstrates how the setup of the string multiway systems shown in the first part effectively encodes a position basis that maps points in branchial space onto corresponding points in physical space, it gives a minimal explicit example of pairs of interacting quantum oscillators to show directly how both constructive and destructive interference effects work within the multiway Wolfram model formalism, and it demonstrates precisely why these interference effects occur, as a consequence of some basic modular arithmetic and the combinatorial consequences of multiway completion rules. In effect, this bulletin may be considered to be a concrete computational instantiation of one of the somewhat more abstract (and correspondingly much more general) mathematical arguments presented within my previous quantum mechanics paper.

In conventional optics, diffraction and interference patterns are governed (at least in the case of near-field Fresnel diffraction phenomena, which is the case that we consider in this bulletin) by the transcendental Fresnel integrals, which can in turn be approximated by products of Chebyshev polynomials (of the second kind) with the `Sinc` function. As such, we can reproduce the spatial intensity plots for the standard single-slit, double-slit and triple-slit interference fringes in the following straightforward way:

✕
Plot[((1/#)*ChebyshevU[# - 1, Cos[x]]*Sinc[0.35*x])^2, {x, -10, 10}, PlotRange -> All] & /@ Range[3] |

In my previous paper on the quantum mechanical foundations of the Wolfram model, I provided a rigorous mathematical formulation of the magnitudes of quantum amplitudes (in terms of path weights in multiway systems), and of quantum phases (in terms of ratios of branchlike- to spacelike-separated events in the multiway causal graph). Thus, an obvious question to ask would be whether we can successfully reproduce these conventional interference patterns using pure string-based multiway systems? Rather gratifyingly, it turns out that the answer is yes: diffraction and interference phenomena essentially “fall out” of my multiway formulation of quantum mechanics in an exceptionally natural way, as we shall now see.

Consider the following elementary string multiway system:

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 4, "EvolutionGraph"] |

It is possible to introduce so-called “path weights” for each vertex in this system, such that every vertex is weighted by the number of distinct evolution paths that lead to it, as follows:

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 4, "EvolutionGraph", "IncludeStatePathWeights" -> True, VertexLabels -> "VertexWeight"] |

From here, we can now “normalize” these path weights by imposing the constraint that all path weights for state vertices produced at a given step in the multiway evolution must sum to 1, like so:

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 4, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"] |

And then, within my formulation of quantum mechanics, in which each global multiway state corresponds to a distinct eigenstate of the universe (i.e. as part of some generalized Hartle–Hawking wavefunction), these normalized state weights correspond neatly to the magnitudes (squared) of the quantum amplitudes for the associated eigenstates.

Now let us construct a toy example of a photon diffraction experiment using an elementary string multiway system; in a very loose sense, we could use the character “X” to denote the “presence” of a photon, and the character “o” to denote the “absence” of a photon, within a given region of space (although precisely how to construct a mathematically consistent position basis from these substrings is a somewhat subtle problem, as will be discussed later in detail in the second part of this bulletin). From here, we can represent a simple approximation to the Huygens–Fresnel principle of wave propagation using the sorting rules “Xo” → “oX” and “oX” → “Xo”, corresponding to a photon scattering right and scattering left, respectively. If we use the initial condition “ooooooooXoooooooo” to denote a single photon entering through a single slit, we therefore obtain the following multiway evolution:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXoooooooo", 10, "EvolutionGraphStructure", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"]] |

We can see that there are exactly nine distinct states present at the final evolution step

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXoooooooo", 10, "AllStatesList", "IncludeStepNumber" -> True, "IncludeStateWeights" -> True]]] |

which means that we can extract the last nine vertex weights (which, due to the automatic string sorting performed by the `MultiwaySystem` function, have been naturally laid out from left to right in the appropriate “position basis”):

✕
weights = Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXoooooooo", 10, "StateWeights", "IncludeStateWeights" -> True], -9] |

Thanks to the symmetry of the string sort, we can actually just plot the last half (5) of the vertex weights, so as to show the intensity pattern on the right-hand side of the fictional experimental “screen”

✕
ListLinePlot[Last /@ Take[weights, -5]] |

and then prepend a swapped version of the last half in order to reconstruct the pattern on the left-hand side:

✕
ListLinePlot[ Last /@ Join[Reverse[Take[weights, -5]], Take[weights, -5]]] |

So is this a single-slit diffraction pattern? It’s a little hard to tell with so few states, but it certainly seems suggestive of one. Let’s try the same procedure again with a larger initial condition (“ooooooooooooooooXoooooooooooooooo”) and more evolution steps, leading to the following (somewhat larger) multiway evolution graph

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooooooooooXoooooooooooooooo", 16, "EvolutionGraphStructure", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"]] |

now containing 17 distinct states at its final evolution step:

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooooooooooXoooooooooooooooo", 16, "AllStatesList", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"]]] |

Once again, extracting the last half of the vertex weights

✕
weights = Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooooooooooXoooooooooooooooo", 16, "StateWeights", "IncludeStateWeights" -> True], -9] |

thus allows us to reconstruct the complete spatial intensity pattern on both sides as:

✕
ListLinePlot[Last /@ Join[Reverse[weights], weights]] |

Compare now against the expected single-slit photon diffraction pattern, as predicted by conventional quantum mechanics:

✕
Plot[(ChebyshevU[0, Cos[x]]*Sinc[0.35*x])^2, {x, -10, 10}] |

Our multiway approximation does indeed seem to be converging to the known analytical result! However, single-slit diffraction is a somewhat trivial phenomenon, since it lacks many of the destructive interference effects that make multi-slit diffraction phenomena so much more complex and interesting. In fact, its triviality can be witnessed explicitly by observing that its branchial graph (and, therefore, the associated projective Hilbert space that describes this particular quantum system) is strictly one-dimensional, reflecting the presence of only a single identifiable quantum subsystem:

✕
ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooooooooooXoooooooooooooooo", 16, \ "EvolutionBranchialGraphStructure"] |

So what happens if we try a two-slit diffraction case? We can do this very easily by just adding a second “X” (corresponding to a second photon propagating through a second slit) to our previous initial condition, with a small separation between the first and second slits, e.g. “oooooooooXoooXooooooooo”, thus yielding the following slightly more complicated evolution graph:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 6, "EvolutionGraphStructure"], AspectRatio -> 1/2] |

There now exist 35 distinct states at the final evolution step:

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 6, "AllStatesList", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True]]] |

So we extract the last half of the state weights

✕
weights = Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 6, "StateWeights", "IncludeStateWeights" -> True], -18] |

and reconstruct the spatial intensity pattern in the usual way:

✕
ListLinePlot[Last /@ Join[Reverse[weights], weights]] |

Okay, now something pretty interesting is starting to happen! We see one large central maximum (as one might expect, given the previous case), but now the maximum has two immediate minima on either side of it, followed by smaller fringe maxima on either side of those etc. Let’s repeat this analysis by running the multiway system for a few more evolution steps, to see what this new pattern might be converging to:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 10, "EvolutionGraphStructure"], AspectRatio -> 1/2] |

Now there are 75 distinct states at the final step

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 10, "AllStatesList", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True]]] |

so by extracting the last half of the state weights

✕
weights = Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 10, "StateWeights", "IncludeStateWeights" -> True], -38] |

we can reconstruct the following higher-resolution spatial intensity pattern:

✕
ListLinePlot[Last /@ Join[Reverse[weights], weights]] |

Comparing once more against the expected double-slit photon diffraction pattern from conventional quantum mechanics

✕
Plot[((1/2)*ChebyshevU[1, Cos[x]]*Sinc[0.35*x])^2, {x, -10, 10}, PlotRange -> All] |

we see astonishingly good convergence to the analytical result, with correct prediction of the relative positions of the minima and the fringe maxima, as well as of the relative intensities of the interference fringes (compared both to the central maximum and to each other) etc. Since there are two interacting quantum subsystems in this second case (one associated with each slit), the branchial graph, and hence the associated projective Hilbert space, is now two-dimensional

✕
ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooooXoooXooooooooo", 10, \ "EvolutionBranchialGraphStructure"] |

where the “rounding off” at the corners of the branchial graph is a simple boundary effect associated with the finite nature of the string.

Finally, just to confirm the robustness of these correspondences, let us consider the three-slit diffraction case, with an example initial state “oooooooXXXooooooo”

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooXXXooooooo", 10, "EvolutionGraphStructure"], AspectRatio -> 1/2] |

yielding 162 distinct states at the final evolution step

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooXXXooooooo", 10, "AllStatesList", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True]]] |

with corresponding weights for the right-hand side of the “screen”:

✕
weights = Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooXXXooooooo", 10, "StateWeights", "IncludeStateWeights" -> True], -81] |

This results in the final spatial intensity pattern

✕
ListLinePlot[Last /@ Join[Reverse[weights], weights]] |

which again compares exceptionally favorably (particularly given the relatively small string size and low number of evolution steps) to the triple-slit diffraction pattern predicted from the usual Fresnel integral approximation

✕
Plot[((1/3)*ChebyshevU[2, Cos[x]]*Sinc[0.35*x])^2, {x, -10, 10}] |

with the associated branchial graph now corresponding, unsurprisingly, to a fully three-dimensional projective Hilbert space:

✕
branchialGraph = ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "oooooooXXXooooooo", 10, "EvolutionBranchialGraphStructure"] |

Therefore it really does seem that, with these very simple string multiway system models of quantum mechanics, we’ve been able to capture both the key qualitative and quantitative aspects of the double-slit experiment, and of quantum interference phenomena more generally, exactly as my formulation originally predicted. But how does any of this actually work? What’s really going on underneath? Ultimately, it’s just a simple theorem of combinatorics (with a smattering of elementary number theory), but understanding intuitively why this theorem holds requires first delving into some of the gory details of position bases, completion procedures, induced causal invariance and the relationship between branchial geometry and quantum phase….

First of all, let me attempt to demonstrate explicitly how the construction of the string position basis works in the particular case of the double-slit setup I described in the last section. I should stress that the scheme I describe here for encoding the position basis in terms of substring positions is only one possible such method, and doubtless it can be improved in many ways. The essential idea here is to encode which “region” contains the photon using the sum of the “X” substring positions, and then to encode precisely where the photon is “within” that region using the difference of those same positions.

For instance, consider the simple two-slit case described previously, defined by an initial condition “ooooooooXXoooooooo”

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXXoooooooo", 6, "EvolutionGraphStructure"], AspectRatio -> 1/2] |

with 28 distinct states at the final step

✕
Length[Last[ ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXXoooooooo", 6, "AllStatesList", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True]]] |

and consider, in particular, the right-hand side of our fictional “experimental apparatus”, characterized by the following 14 states (shown here in the standard order, as sorted internally by `"StateWeights"`):

✕
states = First /@ Take[ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oX" -> "Xo"}, "ooooooooXXoooooooo", 6, "StateWeights", "IncludeStateWeights" -> True], -14] |

In our fictional experimental setup, there exist three distinct spatial regions: a central separator region, a region corresponding to the right-hand slit and a further right-hand separator region. Which of the three spatial regions the photon is contained within is then encoded by the sum of the string positions of the individual “X”s, i.e.

✕
stringPositions = StringPosition[states, "X"] |

where, in this particular case, the sum corresponds to either 21, 23 or 25 (ignoring the 13 and the 19 at the beginning of the following list, which correspond to boundary cutoff effects resulting from the finiteness of the string):

✕
(First[First[#]] + First[Last[#]]) & /@ stringPositions |

The position of the photon within that region is then encoded by the difference in the positions of the two “X”s, which here correspond to either 1, 3, 5 or 7:

✕
(Abs[First[First[#]] - First[Last[#]]]) & /@ stringPositions |

Thanks to this elegant encoding of the position basis, it is therefore guaranteed that, by looking at the last half of the sequence of weights (as previously indicated), these weights will necessarily correspond to the intensities of incident photons at monotonically increasing positions on the fictional experimental “screen”, starting from the center and ending at the far right, exactly as required.

Okay, so that takes care of the mapping between the positions of microstates in branchial space and the corresponding spatial positions of the photons on the “screen”, but how do the crucial concepts of quantum phase and interference make themselves manifest within this particular model of double-slit diffraction? To understand this, we begin by noticing that our simulated “Huygens–Fresnel” rules are trivially causal invariant:

✕
ResourceFunction["TotalCausalInvariantQ"][{"Xo" -> "oX", "oX" -> "Xo"}, 4] |

And, as detailed in my quantum mechanics paper, all causal invariant multiway systems may be considered to have been “derived” by an appropriate application of a Knuth–Bendix completion procedure from a previously “uncompleted” non-causal invariant system, by a process that is directly analogous to wavefunction collapse in the standard Copenhagen interpretation of quantum mechanics. For instance, starting from the following simple multiway system consisting of two independent evolution branches (which we can think of as corresponding to two independent paths of history in which the photon either goes through one slit or goes through the other, in the case of a minimal two-slit diffraction experiment)

✕
ResourceFunction["MultiwaySystem"][{"S" -> "X", "S" -> "Y", "X" -> "X", "Y" -> "Y"}, "S", 4, "EvolutionGraph"] |

we can see that this also constitutes a minimal model for a non-causal invariant multiway system (in which there exists a single branch pair that is guaranteed never to reconverge):

✕
ResourceFunction["TotalCausalInvariantQ"][{"S" -> "X", "S" -> "Y", "X" -> "X", "Y" -> "Y"}, 4] |

However, we can force these two non-intersecting branches to interact (and hence to collapse down to a single effective branch of history) by performing a Knuth–Bendix completion in the standard fashion

✕
completion = ResourceFunction["CanonicalKnuthBendixCompletion"][{"S" -> "X", "S" -> "Y", "X" -> "X", "Y" -> "Y"}] |

thus obtaining the new evolution history

✕
ResourceFunction["MultiwaySystem"][ Join[{"S" -> "X", "S" -> "Y", "X" -> "X", "Y" -> "Y"}, completion], "S", 4, "EvolutionGraph"] |

which is now trivially causal invariant:

✕
ResourceFunction["TotalCausalInvariantQ"][ Join[{"S" -> "X", "S" -> "Y", "X" -> "X", "Y" -> "Y"}, completion], 4] |

So how does a completion procedure achieve the destructive interference effects that are so crucial for reproducing the results of the double-slit experiment just shown? As I described in my quantum mechanics paper, the basic idea is to think of the phase difference between two paths in the multiway system as corresponding to the ratio of branchlike- to spacelike-separated events along those paths (or, strictly speaking, to twice the `ArcTan` of that ratio). Thus, if you have two paths along which every pair of events is purely spacelike separated (corresponding to a pair of isomorphic paths in the multiway system), then the phase difference between the two paths is exactly zero. This implies that the two paths merge and the corresponding state weights add, and so one ultimately achieves perfect constructive interference. If you have two paths along which every pair of events is purely branchlike separated (corresponding to a pair of non-intersecting paths in the multiway system, as seen in the first example), then the phase difference between the two paths is exactly π, meaning that they perfectly destructively interfere.

But how does that destructive interference actually occur? Well, it’s entirely a consequence of the combinatorial structure of the completion procedure. Consider the element “X” within the pair of strings “Xo” and “oX”; in this particular case, the two “X”s are purely spacelike separated across the two states (since they occur in non-conflicting parts of the string), which means that the pair of states can be successfully completed to yield the common state “XX”, and no information is lost (i.e. one has perfect constructive interference). Consider now the element “X” within a pair of strings “Xo” and “XO”; in this new case, the two “X”s are purely branchlike separated across the two states (since they now occur in conflicting parts of the string, i.e. both at position 1), which means that the only consistent completion procedure for the two states will necessarily destroy any information about whether there was an “o” or an “O” at position 2. In other words, any completion procedure will necessarily yield a common state of the form `"X"<>{"O","o"}`, where the `{...}` here denotes an equivalence class of substrings, indicating that the information about whether the previous state contained an “o” or an “O” in at position 2 is now lost (i.e. one has perfect destructive interference).

To see the connection among phase difference, destructive interference and completion procedures more explicitly, it is helpful to consider a minimal illustrative example of a quantum harmonic oscillator, simulated within a simple string multiway system, using a scheme proposed as part of Patrick Geraghty’s Summer School project. Using the pair of rules “Xo” → “oX” and “oY” → “Yo”, we can use the character “X” to simulate a particle traveling from left to right and the character “Y” to simulate the same particle traveling back from right to left. Then we can use the character “O” to denote the boundaries of some finite-sized region of configuration space, with the pair of rules “XO” → “YO” and “OY” → “OX” thus effectively implementing reflective boundary conditions for the oscillating particle. As a consequence, we can change the period of the oscillator by simply modifying the length of the initial string, as shown here (for the case of oscillators corresponding to periods of 4, 6, 8 and 10, respectively)

✕
ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oY" -> "Yo", "XO" -> "YO", "OY" -> "OX"}, #, 10, "StatesGraph"] & /@ {"OXoO", "OXooO", "OXoooO", "OXooooO"} |

with the associated evolution causal graphs:

✕
ResourceFunction["MultiwaySystem"][{"Xo" -> "oX", "oY" -> "Yo", "XO" -> "YO", "OY" -> "OX"}, #, 10, "EvolutionCausalGraphStructure"] & /@ {"OXoO", "OXooO", "OXoooO", "OXooooO"} |

For instance, here is a multiway system consisting of two independent branches—one containing a period-4 oscillator and the other containing a period-6 oscillator:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"S" -> "OXoO", "S" -> "OXooO", "Xo" -> "oX", "oY" -> "Yo", "XO" -> "YO", "OY" -> "OX"}, "S", 7, "StatesGraph"]] |

However, though it is no doubt useful for pedagogical purposes, in practice we don’t actually need all of the “internal structure” of a simulated particle bouncing between two simulated walls; we can just generate the exact same form of a cyclic multiway system using purely single-character rewrite cycles as follows:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "E", "A" -> "B", "B" -> "C", "C" -> "D", "D" -> "A", "E" -> "F", "F" -> "G", "G" -> "H", "H" -> "I", "I" -> "J", "J" -> "E"}, "S", 7, "StatesGraph"]] |

Consider first the simplest nontrivial case of a multiway system containing a pair of period-2 oscillators (the states graph, illustrating the actual cycle structure, is shown on the left, while the unmerged evolution graph is shown on the right):

✕
{ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "C"}, "S", 4, "StatesGraph"], ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "C"}, "S", 4, "EvolutionGraph"]} |

However, since each cycle ultimately corresponds to a single eigenstate of the associated quantum system, we can collapse each cycle down to occupy only a single state vertex in the multiway system (essentially by replacing a state with spatial periodicity 1 and temporal periodicity 2 by an equivalent state with spatial periodicity 2 and temporal periodicity 1), as follows:

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, "S", 4, "EvolutionCausalGraph", "IncludeStepNumber" -> True] |

Since the periods are equal between the two branches, the two oscillators are exactly in phase

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, "S", 6, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"] |

and clearly, since the oscillators are non-interacting, the system is non-causal invariant:

✕
ResourceFunction["TotalCausalInvariantQ"][{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, 4] |

It is intuitively clear that a minimal completion (acting on single characters) would send “A” → “C” and “C” → “A”, as well as “B” → “D” and “D” → “B”. To see programmatically why this must be so, consider the set of canonical branch pairs for this particular system

✕
ResourceFunction["CanonicalBranchPairs"][{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}] |

and note that the greatest common divisor of their lengths is 2

✕
gcd = GCD[StringLength["AB"], StringLength["CD"]] |

which means that we can simply construct the following direct mapping between the characters of the two strings

✕
inputs = StringJoin /@ Partition[Characters["AB"], StringLength["AB"]/gcd] |

✕
outputs = StringJoin /@ Partition[Characters["CD"], StringLength["CD"]/gcd] |

to yield

✕
completionRules = Join[Thread[inputs -> outputs], Thread[outputs -> inputs]] |

exactly as expected. By introducing these new completion rules, we have effectively forced the two period-2 oscillators to interact, thus obtaining the following causal invariant multiway system:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, completionRules], "S", 4, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"]] |

✕
ResourceFunction["TotalCausalInvariantQ"][ Join[{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, completionRules], 4] |

The constructive interference of the two branches is witnessed from the fact that the state weights here remain perfectly stable post-completion:

✕
ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CD", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D"}, completionRules], "S", 6, "StateWeights", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True] |

Consider now a multiway system consisting of a period-2 oscillator and a period-3 oscillator, i.e.

✕
{ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "E", "E" -> "C"}, "S", 6, "StatesGraph"], ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "E", "E" -> "C"}, "S", 6, "EvolutionGraph"]} |

and collapse the eigenstates down to occupy single multiway states in the usual way:

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, "S", 4, "EvolutionCausalGraph", "IncludeStepNumber" -> True] |

Since the periods of the two oscillators differ by a factor of 1/2, we can see that the two multiway branches are therefore exactly π radians out of phase

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, "S", 4, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"] |

and, since it has not been measured, the system is not yet causal invariant:

✕
ResourceFunction["TotalCausalInvariantQ"][{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, 4] |

Due to the mismatch between the periods of the two branches, it is no longer immediately clear what the minimal (single-character) completion procedure should be. Following the same basic algorithm we employed previously, begin by considering the set of canonical branch pairs

✕
ResourceFunction["CanonicalBranchPairs"][{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}] |

and observe this time around that the greatest common divisor of their lengths is 1 (i.e. the lengths are coprime)

✕
gcd = GCD[StringLength["AB"], StringLength["CDE"]] |

so if we attempt to construct the same naive mapping between the characters of the two strings as before

✕
inputs = StringJoin /@ Partition[Characters["AB"], Min[StringLength["AB"], StringLength["CDE"]]] |

✕
outputs = StringJoin /@ Partition[Characters["CDE"], Min[StringLength["AB"], StringLength["CDE"]]] |

then we obtain only a partial set of completion rules

✕
Join[Thread[inputs -> outputs], Thread[outputs -> inputs]] |

since the substring “E” is still unaccounted for. Therefore, we must also incorporate an additional pair of rules allowing one to map from the end of the “AB” string (i.e. the empty string) to the end of the “CDE” string (i.e. the “E” substring), which we can do using elementary modular arithmetic. More precisely, the final 3 (i.e. the string length of “CDE”) modulo 2 (i.e. the string length of “AB”) characters of the “CDE” string must be mapped onto the empty string that terminates “AB”, and vice versa, i.e.

✕
inputs = Append[inputs, ""] |

✕
outputs = Append[outputs, StringTake["CDE", -Mod[StringLength["CDE"], StringLength["AB"]]]] |

to obtain the overall set of completion rules

✕
completionRules = Join[Thread[inputs -> outputs], Thread[outputs -> inputs]] |

thus yielding a causal invariant multiway system in the expected manner, by effectively forcing the two out-of-phase oscillators to interact:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, completionRules], "S", 4, "EvolutionGraphStructure", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"], AspectRatio -> 1/2] |

✕
ResourceFunction["TotalCausalInvariantQ"][ Join[{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, completionRules], 4] |

However, note that the state weights (post-completion), unlike in the earlier constructive case, are now unstable

✕
weights = ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, completionRules], "S", 4, "StateWeights", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True] |

and that, in particular, the weights associated with states “AB” and “CDE” appear to be converging to zero, corresponding to the phenomenon of perfect destructive interference:

✕
N[Select[weights, Last[First[#]] == "AB" || Last[First[#]] == "CDE" &]] |

We can validate this convergence empirically by simply running the multiway system for a couple more evolution steps:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, completionRules], "S", 6, "EvolutionGraphStructure", "IncludeStateWeights" -> True], AspectRatio -> 1/2] |

✕
N[Select[ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDE", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E"}, completionRules], "S", 6, "StateWeights", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True], Last[First[#]] == "AB" || Last[First[#]] == "CDE" &]] |

As a final illustrative step, let us consider a multiway system containing a period-2 oscillator and a period-4 oscillator, as shown here

✕
{ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "E", "E" -> "F", "F" -> "C"}, "S", 8, "StatesGraph"], ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "C", "A" -> "B", "B" -> "A", "C" -> "D", "D" -> "E", "E" -> "F", "F" -> "C"}, "S", 8, "EvolutionGraph"]} |

which, with the eigenstates collapsed down to occupy single multiway states, now looks like this:

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, "S", 4, "EvolutionCausalGraph", "IncludeStepNumber" -> True] |

The periods of the two oscillators thus differ by exactly 2*π, so the two branches are now back in phase with each other

✕
ResourceFunction["MultiwaySystem"][{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, "S", 4, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"] |

and, as usual, the unmeasured system fails to be causal invariant:

✕
ResourceFunction["TotalCausalInvariantQ"][{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, 4] |

Thanks to the exact divisibility of the period of one oscillator by the period of the other, it is clear (by analogy with the earlier case of the two branches with equal periods) that a minimal single-character completion for this case would send “A” → “CD”, “B” → “EF”, in addition to “CD” → “A” and “EF” → “B”, which we can also confirm programmatically by simply computing the list of branch pairs:

✕
ResourceFunction["CanonicalBranchPairs"][{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}] |

Since the greatest common divisor of their lengths is, again, 2

✕
gcd = GCD[StringLength["AB"], StringLength["CDEF"]] |

we are able to construct the following direct mapping between the characters

✕
inputs = StringJoin /@ Partition[Characters["AB"], StringLength["AB"]/gcd] |

✕
outputs = StringJoin /@ Partition[Characters["CDEF"], StringLength["CDEF"]/gcd] |

so as to obtain

✕
completionRules = Join[Thread[inputs -> outputs], Thread[outputs -> inputs]] |

as we had anticipated, such that the (now causal invariant) multiway system for the pair of interacting oscillators, post-completion, takes the form:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, completionRules], "S", 4, "EvolutionGraph", "IncludeStateWeights" -> True, VertexLabels -> "VertexWeight"]] |

✕
ResourceFunction["TotalCausalInvariantQ"][ Join[{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, completionRules], 4] |

The new state weights remain stable, just as in the aforementioned constructive interference case

✕
weights = ResourceFunction["MultiwaySystem"][ Join[{"S" -> "AB", "S" -> "CDEF", "A" -> "A", "B" -> "B", "C" -> "C", "D" -> "D", "E" -> "E", "F" -> "F"}, completionRules], "S", 6, "StateWeights", "IncludeStateWeights" -> True, "IncludeStepNumber" -> True] |

such that, in particular, the weights associated with states “AB” and “CDEF” now converge to finite (nonzero) values, unlike in the destructive example previously shown:

✕
N[Select[weights, Last[First[#]] == "AB" || Last[First[#]] == "CDEF" &]] |

A more rigorous version of this argument using elementary combinatorial number theory is currently under preparation for submission as a short supplementary mathematical note to this bulletin.

]]>This bulletin is a writeup of work done in collaboration with Xerxes Arsiwalla and Stephen Wolfram, as publicly presented and discussed in livestreams here, here and here. This bulletin is intended to be a high-level survey of the effort so far; a more formal article, intended to give rigorous formulations and proofs of the various ideas discussed here, is currently in preparation for submission to an appropriate journal.

The field of “metamathematics”—a term first popularized by David Hilbert in the context of Hilbert’s program to clarify the foundations of mathematics in the early 20th century—may ultimately be regarded as the study of “pre-mathematics”. In other words, while mathematics studies what the properties of particular mathematical structures (such as groups, rings, fields, topological spaces, etc.) may be, metamathematics studies what the properties of mathematics itself, when regarded as a mathematical structure in its own right, are. Metamathematics is thus “pre”-mathematics in the sense that it is the structure from which the structure of mathematics itself develops (much like “pre-geometry” in theoretical cosmology is regarded as the structure from which the structure of the universe itself develops).

In much the same way, the Wolfram Physics Project may be thought of as being the study of “pre-physics”. The Wolfram model is not a model for fundamental physics in and of itself, but rather an infinite family of models (or, if you prefer, a “formalism”), within which concepts and theories of fundamental physics can be systematically investigated and validated. However, one of the most remarkable things that we have discovered over the year or so that we’ve been working on this project is that a shockingly high proportion of the known laws of physics (most notably, both general relativity and quantum mechanics) appear to be highly “generic” features of the formalism, i.e. they are exhibited by a wide class of models, as opposed to being features that are somehow peculiar to our specific universe, as one might otherwise expect. This leads us to the tantalizing possibility that, just as metamathematics aims to explain why mathematics has the structure that it does, the Wolfram model may serve to explain why physics has the structure that it does.

The correspondence between the Wolfram model and foundational metamathematics goes far deeper than this, though. It does indeed appear that many of the recent innovations in the foundations of mathematics (including dependent type theory, homotopy type theory, the univalence axiom, Urs Schreiber’s cohesive geometry, etc.) have considerable overlaps with our recent insights into the foundations of physics (particularly surrounding concepts such as the topology and geometry of rulial space, foliations and fibrations of the rulial multiway system, completion procedures and the inevitability of quantum mechanics, etc.). Indeed, what I aim to sketch out in this bulletin is a potential scheme for a new, computable foundation of both mathematics and physics, which can be thought of as an abstract unification of homotopy type theory and the Wolfram Physics Project.

I will discuss how the symbolic structure of the Wolfram Language’s automated theorem-proving framework reflects the Curry–Howard–(Lambek) correspondence in mathematical logic, and how the Wolfram model naturally generalizes this correspondence to the foundations of physics; I will provide a brief pedagogical introduction to homotopy type theory and the univalent foundations program, as well as to Michael Shulman’s cohesive variant of homotopy type theory and his synthetic differential geometry program; I will then discuss multiway systems as a candidate formalism for investigating ideas in homotopy type theory, with multiway rules corresponding to type constructors, completion rules corresponding to homotopies, etc.; next, I will discuss the significance of Grothendieck’s hypothesis for the origins of geometrical structure in both mathematics and physics, the implications it has for the interpretation of branchial graphs as projective Hilbert spaces, causal graphs as Lorentzian manifolds, etc., and will give informal justifications for our interpretation of the rulial multiway system as an infinity-topos endowed with a Grothendieck topology, as well as discuss the relationship between the univalence axiom and my previously developed “completion” interpretation of quantum mechanics; I will also introduce my new “relativistic” interpretation of the first incompleteness theorem, as a statement of the effective gauge dependence of semantic truth in mathematics, and its implications for the geometrization and computationalization of both proof theory and model theory, as well as the potential significance of the “generalized Einstein field equations” that act in the space of all possible mathematical proofs; I will then give some explicit examples of foliations and fibrations of rulial multiway systems for the special case of finitely presented algebraic structures; finally, I will discuss the geometrical and topological significance of fibrations in the rulial topos and their implications for the foundations of quantum mechanics (and, in particular, I will demonstrate a hitherto undiscovered relationship between the Wolfram model formalism and the dagger symmetric monoidal category formalism of categorical quantum mechanics), before ending with a brief philosophical note about how this new way of thinking about metamathematics and “metaphysics” may yield new insight into why both the laws of mathematics and the laws of physics (particularly those of quantum mechanics and general relativity) are actually true.

Let me begin by describing the broad philosophical setup of this bulletin. In mathematical logic and theoretical computer science, there is a famous result named after Haskell Curry and William Alvin Howard (and deeply connected to the core ideas of intuitionistic logic and its operational interpretation) known as the “Curry–Howard isomorphism” or “Curry–Howard correspondence”. Loosely speaking, what it says is that all mathematical proofs can be interpreted as computer programs, and (somewhat more surprisingly) all computer programs can be interpreted as mathematical proofs. In other words, the core problems of proof theory in mathematical logic and programming language theory in theoretical computer science are actually identical.

At some level, the Curry–Howard isomorphism provides the formal justification for an otherwise obvious intuition. In pure mathematics, one starts from a set of “axioms”, one applies a “proof” (in accordance with a set of “rules of inference”) and one obtains a “theorem”. The abstract notion of computation can thus be thought of as being an ultimately desiccated version of the concept of mathematical proof, in which one starts with some “input”, one applies a “computation” (in accordance with a set of “algorithmic rules”) and one obtains an “output”. In other words, one has the formal correspondence:

✕
<|"Axioms" -> "Input", "Proof" -> "Computation", "Rules of Inference" -> "Algorithmic Rules", "Theorem" -> "Output"|> |

Indeed, the symbolic nature of the Wolfram Language allows us to see this correspondence explicitly. If we prove a trivial mathematical theorem (such as the theorem that *a*==*c*, starting from the axioms *a*==*b* and *b*==*c*, i.e. a proof of the transitivity of the equality predicate), then we obtain a symbolic proof object:

✕
proof = FindEquationalProof[a == c, {a == b, b == c}] |

✕
proof["ProofGraph"] |

✕
proof["ProofDataset"] |

Each statement in the proof, such as “*a*==*c*”, can be interpreted as a symbolic expression. Each application of an inference rule, such as “*a* → *b*” (which is, in turn, derived from the axiom “*a*==*b*”) can be interpreted as an application of a symbolic rewrite rule. Thus, the entire proof can be implemented as a symbolic piece of Wolfram Language code, in which the key steps of the proof are performed using the `MapAt[...]` and `Replace[...]` functions:

✕
proof["ProofFunction"] |

Running this piece of code allows us to determine that the corresponding theorem is actually true:

✕
proof["ProofFunction"][] |

As such, we can interpret the Curry–Howard isomorphism as being the statement that every `ProofObject` in the Wolfram Language has an associated proof function (which we can explicitly demonstrate, as shown previously), and moreover that every piece of symbolic Wolfram Language code has a corresponding interpretation as a `ProofObject` for some theorem. The latter direction is easy to see once one appreciates that all terminating Wolfram Language programs are ultimately reducible to finite sequences of transformation operations being applied to symbolic expressions, just like in a mathematical proof.

To be a bit more rigorous, the Curry–Howard isomorphism involves invoking the so-called “propositions as types” interpretation of metamathematics; in other words, Curry–Howard states that a program that produces an output of a given data type can be interpreted as a proof that the corresponding type is inhabited, and vice versa. (Note that there is also a three-way “Curry–Howard–Lambek” correspondence employed within category theory, in which objects in a “Cartesian closed category” can be interpreted as propositions, and morphisms between those objects can then be interpreted as the corresponding proofs of implication between propositions. We will hint at some details of the Curry–Howard–Lambek correspondence later on in the bulletin when we discuss connections to category theory, but an exhaustive review of this relationship is beyond the scope of this article.)

In the Wolfram Physics Project, and in the field of physics more generally, one also considers an ultimately desiccated notion of what a “physical system” truly is. More specifically, one imagines the system beginning in some “initial state”, undergoing “motion” (in accordance with some “laws of motion”), and ending up in some final state. This immediately suggests a further refinement of the Curry–Howard isomorphism, in which programs, proofs and physical systems are really the same kind of thing:

✕
<|"Initial State" -> "Input", "Motion" -> "Computation", "Laws of Motion" -> "Algorithmic Rules", "Final State" -> "Output"|> |

Viewed in this way, the Church–Turing thesis is neither a definition, a theorem, nor a conjecture; rather it is a hypothesis of fundamental physics. Namely, what the Church–Turing thesis truly says in this context is that the set of partial functions that can be computed by a universal Turing machine is exactly the set of partial functions that is instantiated by the laws of physics. Or, more concretely, the set of possible motions of a (physically realized) universal Turing machine is in one-to-one correspondence with the set of possible motions of any physical system, anywhere in the universe.

The rest of this bulletin will be dedicated to fleshing out the details and implications of this correspondence, both for the foundations of physics and for the foundations of mathematics.

Homotopy type theory is an augmentation of type theory (or, more specifically, of Per Martin-Löf’s intuitionistic type theory) with one key additional axiom, namely Vladimir Voevodsky’s axiom of univalence, whose significance we shall discuss later. The key philosophical idea underpinning homotopy type theory is a slight extension of the usual “propositions as types” interpretation of the Curry–Howard correspondence, in which “types” now correspond to topological spaces (homotopy spaces), “terms” of a given type correspond to points in those spaces, proofs of equivalence between terms of a given type correspond to paths connecting the associated points, proofs of equivalence between proofs correspond to (potentially higher) homotopies between the associated paths, etc. In other words, homotopy type theory is a way of endowing type theory (and the foundation of mathematics more generally) with a kind of inbuilt topological structure.

We know from ordinary topology that a homotopy is just a continuous deformation between paths. More precisely, given a pair of continuous functions *f* and *g* from a topological space *X* to another topological space *Y*, one can define a homotopy as being a continuous function *h* from the product space of *X* with the (closed) unit interval to *Y*, where the unit interval can be thought of as “parameterizing” that homotopy. To see this explicitly, suppose that we define function *f* to just be an ordinary `Sin` function:

✕
f[x_] := Sin[x] |

✕
Plot[f[x], {x, 0, Pi}] |

In homotopy type theory, we would interpret this overall space as being a type, the endpoints of this path would be terms of that type and the path defined by the function *f* would correspond to the proof that those terms are equivalent. Now, in ordinary mathematics, we are used to the idea that a given theorem can have many (apparently distinct) proofs, such as in the case of the fundamental theorem of algebra, in which there is a great variety of possible proofs stemming from topology, complex analysis, abstract algebra, Riemannian geometry, etc. So suppose instead that we define *g* to be a slightly different function connecting the same two points:

✕
g[x_] := Sin[x]*Cos[x] |

✕
Plot[g[x], {x, 0, Pi}] |

Now we can interpret this path as being a different possible proof of the same proposition (namely the proposition that the terms corresponding to the endpoints of the path are equivalent). We can then define a smooth homotopy between these two paths as follows:

✕
h[x_, t_] := (1 - t)*f[x] + t*g[x] |

✕
Plot3D[h[x, t], {x, 0, Pi}, {t, 0, 1}] |

Although this homotopy lives naturally within this higher-dimensional space, we can easily project it back down onto our original space:

✕
Show[Table[ Plot[h[x, t], {x, 0, Pi}, PlotRange -> All], {t, 0, 1, 0.1}]] |

Finally, this homotopy can be interpreted itself as being a proof that the two original (different) proofs are actually equivalent (in the sense that they both constitute valid proofs of the same theorem). As we have now seen explicitly, this homotopy can itself be interpreted as a path in some higher-dimensional space, so we can also proceed to define homotopies between those paths, which would correspond to proofs of equivalence between proofs of equivalence of proofs etc. Thus, there is actually a whole infinite hierarchy containing all possible higher-order homotopies, corresponding to the infinite hierarchy of all possible higher-order proofs of equivalence, and this hierarchy will become relevant to our discussion soon, once we start considering its implications for the geometry and topology of rulial space.

The effort to formalize mathematics in terms of homotopy type theory is commonly known as the “univalent foundations program”, in reference to the central role played by Voevodsky’s univalence axiom. One of the “big-picture” questions driving the advancement of univalent foundations (as well as many related areas, such as Michael Shulman’s formulations of “synthetic topology”, “cohesive geometry”, etc.) is a desire to better understand the role played by “space” in the foundations of mathematics.

In some ways, it is a great mystery why so many different mathematical structures (such as groups, rings, fields, Boolean algebras, lattices, etc.) somehow also come naturally equipped with a corresponding notion of “space”. For instance, in the context of group theory, a group is usually defined purely algebraically (i.e. as a closed algebraic structure obeying the axioms of associativity, identity and inverse), and yet one nevertheless has Lie groups, topological groups, matrix groups, loop spaces, etc., within all of which there naturally appears some kind of corresponding spatial structure (such as a differentiable manifold in the case of a Lie group, or a topological space in the case of a topological group, etc.), which just seems to “come along for the ride”, in the sense that the spatial structure is somehow respected by all of the underlying algebraic operations, without ever being explicitly “told” to do so.

We can make this idea manifest by considering the case of the Lie group SO(3). First, consider the set of all 3 × 3 orthogonal matrices of determinant 1; here, we shall look directly at a finite subset:

✕
elements = RotationMatrix[#, {1, 0, 0}] & /@ Range[0, 2 Pi, Pi/4] |

Then, SO(3) can be defined purely syntactically in terms of a binary operation on this set of elements (in this case, corresponding to the operation of matrix multiplication) that obeys the axioms of associativity:

✕
elements[[ 1]].(elements[[2]].elements[[3]]) == (elements[[1]].elements[[ 2]]).elements[[3]] |

identity:

✕
elements[[1]].elements[[2]] == elements[[2]] |

and inverse:

✕
elements[[2]].elements[[-2]] == elements[[1]] |

However, because of the natural interpretation of 3 × 3 orthogonal matrices of determinant 1 as 3D rotation matrices, SO(3) comes naturally equipped with a spatial structure corresponding to the following differentiable manifold (and, hence, is indeed a Lie group):

✕
SphericalPlot3D[1, {t, 0, 2 Pi}, {f, 0, 2 Pi}] |

But why? The ZFC axioms of set theory are purely syntactical and algebraic: there is no inherent notion of “space” in ZFC. So why should objects (like groups) defined within ZFC in a purely syntactical and algebraic way induce a notion of space as if by magic? Homotopy type theory aims in part to address this mystery of the origin of space, by considering instead a foundation for mathematics that is explicitly spatial and topological at the outset, and in which the other aspect of mathematics (namely its syntactical structure) is somehow emergent.

In the context of the Wolfram Physics Project, we found ourselves addressing a very similar question. Our models are defined purely combinatorially, in terms of replacement operations on set systems (or, equivalently, in terms of transformation rules on hypergraphs). And yet, the correspondence between our models and the known laws of physics depends upon there existing a reasonable interpretation of these combinatorial structures in terms of continuous spaces. My derivation of the Einstein field equations, for instance, depends upon spatial hypergraphs having a reasonable continuum limit in terms of Riemannian manifolds (and hence on them being a reasonable candidate for physical space):

✕
ResourceFunction[ "WolframModel"][{{x, y, x}, {x, z, u}} -> {{u, v, u}, {v, u, z}, {x, y, v}}, {{0, 0, 0}, {0, 0, 0}}, 600, "FinalStatePlot"] |

And, moreover, it depends upon causal graphs having a reasonable continuum limit in terms of Lorentzian manifolds (and hence on being a reasonable candidate for spacetime):

✕
ResourceFunction[ "WolframModel"][{{x, y, x}, {x, z, u}} -> {{u, v, u}, {v, u, z}, {x, y, v}}, {{0, 0, 0}, {0, 0, 0}}, 600, "CausalGraph"] |

And, at a more abstract and speculative level, some of my more recent conjectures regarding the quantum mechanical aspects of our formalism depend upon the continuum limits of branchial graphs in multiway systems being interpretable in terms of projective Hilbert spaces:

✕
ResourceFunction["MultiwaySystem"][{"A" -> "BB", "BB" -> "AA"}, "A", 12, "BranchialGraphStructure"] |

Or multiway causal graphs as being akin to twistor correspondence spaces:

✕
ResourceFunction["MultiwaySystem"][{"A" -> "BB", "BB" -> "AA"}, "A", 8, "CausalGraphStructure"] |

So could these two questions be related? Could the explanations offered by homotopy type theory for the origins of spatial structure in mathematics also imply, after appropriate translation, equivalent explanations for the origins of spatial structure in physics? And, if so, what would the things that we’ve recently discovered in the course of the Wolfram Physics Project so far imply regarding the foundations of (meta)mathematics?

As discussed previously, the axioms of a mathematical theory can be interpreted as defining sets of transformation rules between symbolic expressions. For instance, in the axioms of group theory:

✕
AxiomaticTheory["GroupAxioms"] |

The associativity axiom can be interpreted as the following pair of (delayed) pattern rules:

✕
CircleTimes[a_, CircleTimes[b_, c_]] :> CircleTimes[CircleTimes[a, b], c] |

✕
CircleTimes[CircleTimes[a_, b_], c_] :> CircleTimes[a, CircleTimes[b, c]] |

And therefore a proof of a mathematical proposition can ultimately be represented as a multiway system. Indeed, at some level, this is precisely what a `ProofObject` is:

✕
proof = FindEquationalProof[ AxiomaticTheory["GroupAxioms", "NotableTheorems"][ "ImpliesMcCuneAxioms"], AxiomaticTheory["GroupAxioms"]] |

✕
proof["ProofGraph"] |

When I first started developing `FindEquationalProof` back in 2017, I designed the `ProofObject` to be formatted a little differently to the way multiway systems are conventionally formatted. The green (downward-pointing) arrows are the axioms, the dark green diamond is the hypothesis and the red square is the conclusion (in this case, the conclusion being that the corresponding hypothesis is true). Each of the orange circles is a substitution lemma, and can be thought of as being an ordinary multiway state node: it’s an intermediate lemma that is deduced along the way by simply applying the axiomatic transformation rules described before, just like in a regular multiway system. However, each of the dark orange triangles is a critical pair lemma, which is an indication of a place where the multiway system bifurcates, and in which an additional lemma is required in order to prevent it from doing so (in other words, it corresponds to a place where a completion procedure has been applied). Looking at a specific example of such a lemma

✕
proof["ProofDataset"][5]["Proof"] |

we see here that two rules, indicated by “Rule” and “MatchingRule” (derived from axiom 2 and axiom 1, respectively) both match a common subpattern, indicated by “Subpattern”, and produce (syntactically) inequivalent expressions, thus producing a bifurcation in the multiway system. However, since both elements in the bifurcation were derived from a common expression by valid application of the rewrite rules, this bifurcation itself constitutes a proof that the two elements are equivalent, and hence we can declare them to be equal (which is the statement of the critical pair lemma). This declaration of equivalence immediately forces the bifurcation to collapse, so we deduce that by adding a sufficient number of critical pair lemmas to the rewrite system, we can therefore force the multiway system to have only a single path (at least up to critical pair equivalence). This, incidentally, is identical to the process of adding critical pair completions so as to force causal invariance in the Wolfram model, which (as I first proposed back in 2019) is the formal basis of our current operational model for quantum measurement; this deep correspondence with the foundations of quantum mechanics will be explored in more detail later.

Therefore, the proof graph may be thought of as being a kind of intermediate object between a single evolution thread and a whole multiway system; the substitution lemmas by themselves indicate the path of a single evolution thread, but the critical pair lemmas indicate the places where that evolution thread has been “plumbed into” a large, and otherwise bifurcating, multiway system. We can see this correspondence more directly by considering a simple string multiway system:

✕
mwGraph = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraph"] |

We can clearly see that the strings “AA” and “ABBBABBB” are connected by a path in the multiway system—a fact that we can visualize more explicitly like so:

✕
path1 = FindShortestPath[mwGraph, "AA", "ABBBABBB"] |

✕
HighlightGraph[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], Subgraph[mwGraph, path1]] |

In effect, we can interpret this path as being a proof of the proposition that “AA” → “ABBBABBB”, given the axiom “A” → “AB”. To make the correspondence manifest, with a small amount of additional code we can also represent this path directly as a `ProofObject`:

✕
convertStringToOperator[string_String] := Module[{expression, list}, list = StringSplit[string, ""]; expression = list; While[Length[list] > 1, expression = expression /. list -> (CircleDot[ToExpression[First[list]], Rest[list]]); list = Rest[list]]; expression /. list -> ToExpression[First[list]]] proof = Module[{theorems, axioms, stringTheorems, stringAxioms}, theorems = {"AA" -> "ABBBABBBB"}; axioms = {"A" -> "AB"}; stringTheorems = (convertStringToOperator[First[#]] == convertStringToOperator[Last[#]]) & /@ theorems; stringAxioms = (convertStringToOperator[First[#]] == convertStringToOperator[Last[#]]) & /@ axioms; Evaluate[ FindEquationalProof[stringTheorems, Join[stringAxioms, {ForAll[{a, b, c}, CircleDot[a, CircleDot[b, c]] == CircleDot[CircleDot[a, b], c]]}]]] /. "EquationalLogic" -> "StringLogic"] |

✕
proof["ProofGraph"] |

✕
proof["ProofDataset"] |

Of course, a key idea in homotopy type theory is that we can consider the existence of multiple paths connecting the same pair of points, and hence multiple proofs of the same proposition. For instance, take:

✕
path2 = DeleteDuplicates[ Join[FindShortestPath[mwGraph, "AA", "ABBBA"], FindShortestPath[mwGraph, "ABBBA", "ABBBABBB"]]] |

✕
HighlightGraph[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], {Subgraph[mwGraph, path1], Subgraph[mwGraph, path2]}] |

Homotopy type theory then tells us that we can represent the proof of equivalence of these proofs as a homotopy between the associated paths. Since an (invertible) homotopy is ultimately just a mapping from points on one path to corresponding points on the other path (and back again), this is easy to represent discretely as follows:

✕
homotopy = Join[Thread[path1 -> path2], Thread[path2 -> path1]] |

✕
HighlightGraph[ GraphUnion[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], Graph[homotopy]], {Subgraph[mwGraph, path1], Subgraph[mwGraph, path2], homotopy}] |

However, this homotopy is kind of a “fake”, in the sense that it has been explicitly “grafted on” to the multiway system after the fact. The more “honest” way to enact a homotopy of this kind would be to define explicit multiway rules mapping from states along one path onto states along the other, thus yielding:

✕
LayeredGraphPlot[ HighlightGraph[ ResourceFunction["MultiwaySystem"][Join[{"A" -> "AB"}, homotopy], "AA", 8, "StatesGraphStructure"], {Subgraph[mwGraph, path1], Subgraph[mwGraph, path2], homotopy}]] |

This new multiway system is analogous to the higher-dimensional space in which we constructed a continuous homotopy earlier on in the bulletin; by “projecting down” onto the lower-dimensional multiway system, we are able to infer equivalence between the corresponding proofs. This process of adding invertible rules mapping from one point along a branch to another is precisely what a completion procedure on critical pairs does, as commonly enacted in automated theorem-proving systems, as well as within our present interpretation of quantum measurement. The correspondence among critical pair completion, quantum measurement and homotopies can thus be seen directly for the first time, although to make this correspondence mathematically rigorous requires first understanding its connection to the univalence axiom, as we shall see later.

As Xerxes Arsiwalla pointed out, it is therefore appropriate to think of the multiway rules (like “A” → “AB”) as being analogous to type constructors in mathematical logic (i.e. rules for building new types), so as to allow the multiway systems themselves to be interpreted as inductive types, just as homotopy type theory requires. Moreover, these completion procedures described previously that allow us to define homotopies between paths are a kind of higher-order rule (i.e. they are rules for generating new rules, namely the completion rules), with the result being that the higher-dimensional multiway system that one obtains after applying such a completion procedure is the analog of a higher inductive type. Since there exists an infinite hierarchy of higher inductive types, it follows that there must exist a correspondingly infinite hierarchy of higher-order multiway systems, with the multiway system at level *n* being a partially “completed” version of the multiway system at level *n* – 1 (i.e. in which certain explicit homotopies have been defined between particular pairs of paths). So a natural question to ask is: what kind of mathematical structure would such a hierarchy represent?

In category theory, a “category” is just a collection of objects (which can be represented as nodes), along with a collection of “morphisms” between those objects (which can be represented as directed edges), and with the property that all morphisms are both associative and reflexive (i.e. there exists an identity morphism for each object). For instance, starting from a directed graph

✕
graph = Graph[DirectedGraph[RandomGraph[{5, 5}], "Random"], VertexLabels -> Automatic] |

we can force every directed edge (i.e. every morphism) to be associative by computing the transitive closure:

✕
transitiveClosure = TransitiveClosureGraph[graph] |

From here, we can then enforce reflexivity by adding a single self-loop (i.e. an identity morphism) around each vertex:

✕
category = Graph[GraphUnion[transitiveClosure, Graph[DirectedEdge[#, #] & /@ VertexList[transitiveClosure]]], VertexLabels -> Automatic] |

Thus, this directed graph has a bona fide interpretation as a small category (“small” because the corresponding directed graph is finite). On the other hand, a “groupoid” is a special case of a category in which all morphisms are invertible (and hence are isomorphisms), which we can again demonstrate purely graph-theoretically by converting our directed graph into an undirected one:

✕
groupoid = UndirectedGraph[category] |

Or, to be even more explicit, we could add two-way directed edges to indicate the isomorphisms more directly:

✕
groupoid = DirectedGraph[UndirectedGraph[category]] |

Groupoids are so named because they generalize the structure of ordinary algebraic groups; a group can essentially be thought of as being a special case of a groupoid that contains just a single object, and where the single invertible morphism corresponds to the (unary) group inverse operation.

Closely related to groupoids are objects known as “topoi”, which can be thought of as being the abstract categorical generalization of point-set topology. A “topos” is a category that “behaves like” the category of sets (or, to be more precise, like the category of sheaves of sets on a given topological space) in some suitably well-defined sense. The crucial feature of a topos that relates it to a groupoid, however, is that topoi necessarily possess a notion of “localization”.

In ordinary commutative algebra, rings are not required to possess multiplicative inverses for all elements, so one can “localize” the ring by introducing new denominators (such that the localization is like a restricted version of the field of fractions), thereby introducing multiplicative inverses for elements where they did not previously exist. Similarly, the localization of a category introduces some inverse morphisms where they did not previously exist, hence converting some collection of morphisms into isomorphisms, and thus causing the category to behave “locally” like a groupoid. All of our multiway systems are naturally equipped with a notion of localization; for instance, consider the string multiway system that we explored earlier:

✕
mwGraph = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"] |

We can now select 10 edges at random and introduce their reverse directed edges, so as to simulate adding inverse morphisms for a collection of 10 random morphisms.

✕
reversedEdges = Reverse /@ RandomChoice[EdgeList[mwGraph], 10] |

✕
GraphUnion[mwGraph, Graph[reversedEdges]] |

Much like in the foliation example given previously, this method of localization is kind of a “fake”, since we are just artificially grafting these inverted edges onto a preexisting multiway graph. Instead, we can simply adjoin the reversed edges as a new set of multiway rules:

✕
localization = (First[#] -> Last[#]) & /@ reversedEdges |

✕
ResourceFunction["MultiwaySystem"][ Join[{"A" -> "AB"}, localization], "AA", 8, "StatesGraphStructure"] |

Applying this localization procedure to the entire multiway rule, unsurprisingly, yields the following groupoid-like structure:

✕
ResourceFunction["MultiwaySystem"][{"A" -> "AB", "AB" -> "A"}, "AA", 8, "StatesGraphStructure"] |

Since, in the category of sets, all objects are sets and all morphisms are functions from sets to sets, and because for any function from set A to set B there can exist (at least locally) an inverse function from set B to set A, the category of sets is trivially localizable. It is in this sense that we can say that more general kinds of topoi “behave like” the category of sets.

One can make this correspondence more mathematically rigorous by realizing (as noted by Xerxes) that, when interpreting multiway systems as inductive types and the associated multiway rules as type constructors, then so long as one includes a “subobject classifier” (namely a special object in the category that generalizes the notion of a subset identifier, where all subobjects of a given object in the category correspond to morphisms from the subobject onto the subobject classifier), and assuming that finite limits exist (where a limit is just a categorical construction that generalizes the universal constructions of products and pullbacks), the resulting multiway system that one obtains is precisely an elementary topos. We have furthermore made the conjecture (although we do not yet know how to prove it) that this subobject classifier is what endows our multiway systems with the concept of “foliation” that is so crucial for constructing branchial spaces, and for deducing both quantum mechanics and general relativity in the appropriate continuum limits, since, at least intuitively, each hypersurface in the foliation may be thought of as corresponding to a subobject in the corresponding category. We shall explore this conjecture more closely, and examine precisely what foliations of multiway systems mean from a metamathematical standpoint, within the next section.

For the time being, however, it suffices to realize that such an elementary topos comes naturally equipped (thanks to various results in cohesive geometry) with a functor (that is, a map between categories) to the topos of sets, as well as a pair of adjoint functors (where adjunction refers here to a kind of “weak” equivalence relation between functors) admitting the discrete and indiscrete topologies, respectively. Free topoi possessing this particular collection of functors provide a means of formalizing the notion of a topological space.

As discussed earlier, inducing a homotopy between two paths (or, equivalently, applying a completion procedure between multiway branches) can be thought of as introducing new, higher-order “rules of rules”, and hence has the effect of producing a higher-order object than the type (or multiway system) that one originally started with. This notion of “higher-order” objects can be made more precise using the language of category theory; if each path is interpreted as a morphism between objects (known as a “1-morphism”), then a homotopy can be interpreted as a morphism between 1-morphisms (known as a “2-morphism”), with the resultant structure being a “2-category”. Homotopies of homotopies can hence be interpreted as 3-morphisms within 3-categories, and so on, thus producing a whole infinite hierarchy of higher-order categories. The limit of this hierarchy is known as the “infinity-category”, which we can think of as being the structure obtained by inducing all possible homotopies (and, consequently, by applying all possible completion procedures) to a given multiway system.

In fact, by applying all possible completion procedures, and therefore applying all possible rules for generating rules, etc., we will inevitably populate the space of all possible rules of a particular size, so the resulting structure can also be thought of as being a “rulial multiway system”, defined in the conventional sense. Moreover, since each completion procedure introduces new inverse morphisms where they didn’t previously exist, and hence also enacts a certain kind of localization, the limiting structure is actually an “infinity-groupoid”. An infinity-groupoid is a “quasi-category” (i.e. a weakening of the definition of an ordinary category in which the composition of two morphisms need not be uniquely defined, and therefore in which the equalities that normally appear in the axioms of identity and associativity are replaced by isomorphisms up to higher homotopy), in which all morphisms are necessarily isomorphisms.

This realization is significant because of Grothendieck’s so-called “homotopy hypothesis”, which states that all infinity-groupoids can be interpreted as topological spaces (and consequently that all models of infinity-groupoids can be interpreted as homotopy types), which is ultimately one of the foundational assumptions of homotopy type theory. If Grothendieck’s hypothesis is true, it therefore provides rigorous justification for the claim that the rulial multiway system (which, as we have established, admits a natural interpretation as an infinity-groupoid) is itself a topological space, and hence is naturally endowed with a spatial structure. One immediate consequence of this is that, if we interpret the rulial multiway system as being a fibration, with the individual fibers corresponding to ordinary (non-rulial) multiway systems, and with spacetime causal graphs corresponding to the fibers of those multiway systems, etc., as we shall justify formally later, Grothendieck’s hypothesis effectively explains why our various combinatorial structures, such as multiway systems, branchial graphs, causal graphs, hypergraphs, etc., are additionally endowed with the spatial structures of things like projective Hilbert spaces and Lorentzian spacetimes: they are simply inheriting the spatial structure that is naturally endowed upon the rulial multiway system, as a consequence of the nature of these fibrations. We shall explore more precisely how this works momentarily.

We have so far neglected to mention the role that Voevodsky’s univalence axiom plays within this whole discussion. In the foundations of mathematics, the notion of “extensionality” commonly refers to the criteria by which objects are deemed to be identical (e.g. the “axiom of extensionality” in axiomatic set theory states that two sets are identical if and only if they contain the same elements); extensionality is thus the logical analog of a “`StateEquivalenceFunction`” in the case of our multiway system formalism. In conventional mathematical logic, “propositional extensionality” asserts that a pair of propositions may be considered identical if and only if they logically imply each other.

The univalence axiom is a grand generalization of the principle of propositional extensionality to what we may otherwise call “type extensionality”; it claims that two types can be considered identical if and only if they are equivalent (in the sense that they are connected by paths in the associated homotopy space). In fact, the statement of the axiom is a little bit more subtle than that (since it claims that the “if and only if” in the previous statement is itself a type-theoretic equivalence relation). But this captures the essential underlying idea.

When one induces a homotopy between two independent paths in a multiway system (which we can interpret as being a critical pair completion in the context of quantum measurement, or a proof of equivalence between proofs in the context of homotopy type theory), we effectively treat the corresponding paths as being identical, in the sense that they proceed to evolve as an effective single path in the multiway system. For instance, consider the following minimal case of a multiway system containing a single bifurcation that does not resolve:

✕
ResourceFunction["MultiwaySystem"][{"S" -> "A", "S" -> "B", "A" -> "AA", "B" -> "BB"}, "S", 3, "StatesGraph"] |

These two paths currently act as totally separate and disconnected branches, but if we now perform a critical pair completion

✕
completion = ResourceFunction["CanonicalKnuthBendixCompletion"][{"S" -> "A", "S" -> "B", "A" -> "AA", "B" -> "BB"}] |

the resultant multiway system behaves as though there is only a single path, since now there are new rules permitting one to “jump” instantaneously from one branch to the other:

✕
LayeredGraphPlot[ ResourceFunction["MultiwaySystem"][ Join[{"S" -> "A", "S" -> "B", "A" -> "AA", "B" -> "BB"}, completion], "S", 3, "StatesGraph"]] |

We are justified in treating these two paths as identical precisely because they are equivalent (thanks to their common ancestry in the “S” state). In other words, the formal justification for our interpretation of quantum measurement in the context of the Wolfram model, just like the formal justification for the identification of homotopy-equivalent paths in homotopy type theory, comes directly from the univalence axiom. Or, to put it slightly more poetically, quantum measurement, at least within our formalism, is simply “applied univalence” in a very precise sense.

We can think of “objective reality” in the context of mathematics as being effective causal invariance induced by the univalence axiom. We can also think of “objective reality” in the context of quantum mechanics as being effective causal invariance induced by the act of measurement. Both can be represented purely in terms of critical pair completions, and the correspondence between the two will be demonstrated in a very direct way later on.

Kurt Gödel’s proof of the incompleteness theorems in 1931 established, via the ingenious technique of Gödel numbering, that Peano arithmetic (the standard axiom system for integer arithmetic) was capable of universal computation. Therefore, in particular, he demonstrated that Peano arithmetic could be set up so as to encode the statement “This statement is unprovable.” as a statement about ordinary natural numbers. Clearly, if this statement is true, then it is unprovable (so Peano arithmetic is incomplete), and if it is false, then it is provable (so Peano arithmetic is inconsistent).

As such, one way to phrase the first incompleteness theorem is “If Peano arithmetic is consistent, then there will exist propositions that are independent of the Peano axioms”. In other words, there will exist propositions where neither the proposition nor its negation are (syntactically) provable using the axioms of Peano arithmetic in any finite time. Thus, the first incompleteness theorem is ultimately a proof-theoretic statement: it concerns the class of propositions that are syntactically provable, independent of any semantic interpretation of the terms.

On the other hand, model theory studies what happens when one endows a mathematical theory with a concrete semantic interpretation of its propositional terms. For instance, returning to our previous example of the axioms of group theory, we have:

✕
AxiomaticTheory["GroupAxioms"] |

Everything that we have discussed so far has concerned what can be proven purely on the basis of the syntax of these axioms, in which terms like a, b and c (for instance, in the case of the associativity axiom) can take the form of any arbitrary symbolic expression. However, if one now defines an explicit “domain of discourse” (e.g. a set over which one is quantifying, such that a, b and c now correspond to elements of that particular set), then one has thereby defined a model, with the resulting semantic interpretation now introducing an additional richness of structure that was absent in the “mere” proof theory.

Incompleteness also admits a model-theoretic interpretation, in addition to a purely proof-theoretic one. For instance, Kurt Gödel and Paul Cohen (in 1940 and 1963, respectively) proved that the continuum hypothesis regarding the relative cardinalities of infinite sets is independent of the axioms of ZFC set theory. One way of understanding this result is that Gödel proved that there must exist models of ZFC in which the continuum hypothesis is semantically true (i.e. ZFC + CH is consistent if and only if ZFC is consistent), whereas Cohen proved, using his technique of set-theoretic forcing, that there must exist models of ZFC in which the continuum hypothesis is semantically false (i.e. ZFC + CH is inconsistent). Therefore, if ZFC is consistent, then the continuum hypothesis must be independent of the axioms, because any statement that is syntactically provable must be semantically true in all models, if the underlying system is consistent.

Therefore, I believe that our formalism permits the following new “pseudo-relativistic” interpretation of the first incompleteness theorem: incompleteness is ultimately just a statement of gauge dependence in mathematics.

In the conventional mathematical treatment of relativity, the conformal structure of spacetime induces a partial order (namely the “causal” partial order) on spacetime events. Since there are generically many different total orders that are consistent with a given partial order, we can infer that there are many possible gauge choices/reference frames/foliations of the spacetime that are consistent with the causal partial order generated by its conformal geometry. Thus, the requirement for Lorentz symmetry ultimately corresponds to the statement that the ordering of timelike-separated events (i.e. events whose ordering is specified by the partial order) is gauge invariant, but the ordering of spacelike-separated events is gauge dependent.

Accordingly, my basic claim is that proof theory defines a partial order on the space of all possible mathematical propositions, and choices of models are coordinatizations of the space of mathematical proofs that are analogous to the choices of gauge that allow one to construct total orders that are consistent with this partial order. As such, there will exist propositions whose truth is gauge invariant (namely those that are syntactically provable, as defined by proof theory), and there will exist propositions whose truth is gauge dependent (namely those that are either semantically true or semantically false, but otherwise independent of the axioms, as defined by model theory). To see this explicitly, consider our usual string multiway system:

✕
mwGraph = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraph"] |

A proposition such as “ABAB” → “ABBBBABB” is syntactically provable, since there exists a finite path (or a “chain”) through the partial order of the multiway system such that “ABBBBABB” is preceded by “ABAB”:

✕
path = FindShortestPath[mwGraph, "ABAB", "ABBBBABB"] |

✕
HighlightGraph[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], Subgraph[mwGraph, path]] |

On the other hand, a proposition such as “AABB” → “ABBA” is not syntactically provable, since the two expressions form an anti-chain, so their relative order is not specified by the partial order of the multiway system, and this therefore corresponds to an undecidable proposition (i.e. a proposition that is independent of the underlying axioms that define the multiway system):

✕
FindShortestPath[mwGraph, "AABB", "ABBA"] |

However, we know that there will exist models in which this proposition is semantically true, which we can see directly by making the following explicit gauge choice:

✕
CloudGet["https://wolfr.am/KXgcRNRJ"] |

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 8, "StatesGraph", Epilog -> straightFoliationLines[{1, 0}, {0, 0}, # &, {0, 0}]] |

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 8, "StatesGraph", Epilog -> straightFoliationLines[{1, 0}, {0.7, 0}, # &, {0, 0}]] |

Here, we can see directly that “ABBA” is preceded by “AABB” in the total order induced by the foliation, and so this model is clearly consistent with the proposition. However, consider an alternative gauge choice:

✕
ResourceFunction["MultiwaySystem"][ "A" -> "AB", "AA", 8, "StatesGraph", Epilog -> straightFoliationLines[{1, 0}, {-0.7, 0}, # &, {0, 0}]] |

We see now that that “AABB” is preceded by “ABBA” in this new total order, so the proposition “AABB” → “ABBA” is not consistent with the induced ordering, and therefore the corresponding model is inconsistent with the proposition.

Note that these foliations all correspond to “flat” or “inertial” reference frames, which correspond to what we might call “free models” (i.e. models within which, when viewed as an algebraic structure equipped with finitary operations, the only nontrivial equations that hold between elements of the model are those defined by the axioms themselves, plus one additional relation defining the slope of the foliation, by analogy with “free groups”, “free algebras”, “free lattices”, etc.). Of course, in general, models can have arbitrary additional sets of constraints and equations, and hence will induce the analog of more arbitrary “non-inertial” reference frames, e.g:

✕
CloudGet["https://wolfr.am/LbdPPaXZ"]; |

✕
drawFoliation[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraph"], {{"AABB", "ABABB", "ABAB", "ABBA"}, {"AABBBB", "ABABBBB", "ABBABBB", "ABBABB", "ABBBAB", "ABBBBA"}, {"AABBBBBBB", "ABABBBBBB", "ABBABBBBB", "ABBABBBB", "ABBBABBB", "ABBBBABB", "ABBBBAB", "ABBBBBA"}}, {0.1, 0}, Directive[Hue[0.89, 0.97, 0.71], AbsoluteThickness[1.5]]] |

The precise connection between foliation choices and sets of relations in the presentation theory of algebraic structures will be outlined in the next section. For the time being, though, considering more arbitrary classes of possible foliations naturally presents the question of what concepts like “curvature” correspond to in the context of the space of all possible mathematical proofs. Considering, as we have previously, each possible proof as corresponding to a different geodesic within this space, we infer that the presence of a vanishing Ricci curvature (i.e. a space in which geodesics neither converge nor diverge) thus corresponds to the case in which all proofs consist of entirely linear sequences of substitution rule applications with no resultant bifurcation, and thus no need for critical pair lemmas, e.g.:

✕
proof1 = FindEquationalProof[ a == f, {a == b, b == c, c == d, d == e, e == f}] |

✕
proof1["ProofGraph"] |

✕
proof1["ProofDataset"] |

One implication of the presence of this vanishing Ricci curvature is that making an infinitesimal perturbation to this geodesic (e.g. by “pulling back” one of the intermediate substitution lemmas so as to make it part of the axioms) will exert only a minimal effect on the length of the geodesic (e.g. shortening the proof length by just 1 step):

✕
proof2 = FindEquationalProof[a == f, Join[{a == b, b == c, c == d, d == e, e == f}, {proof1["ProofDataset"][[8]]["Statement"]}]] |

✕
proof2["ProofGraph"] |

✕
{proof1["ProofGraph"], Graph[proof2["ProofGraph"], VertexLabels -> None]} |

Conversely, each critical pair lemma is an indication of the presence of an elementary non-holonomy in the associated manifold (since each critical pair describes an elementary triangle in the multiway system, and so the presence of an unresolved critical pair indicates a failure of parallel transport around the associated triangle to preserve geometrical information, since the two “endpoints” of the triangle end up at different points in the proof space). Since the Riemann curvature tensor measures the failure of commutativity of the covariant derivative operator on an arbitrary Riemannian manifold, we can therefore think of the critical pair lemma density in a particular “direction” as being the analog of the projection of the Riemann curvature tensor in proof space. For instance, the proof of commutativity of the “Wolfram axiom” for Boolean algebra contains a high density of critical pair lemmas, and therefore corresponds to a geodesic propagating through a space with a non-vanishing curvature:

✕
proof1 = FindEquationalProof[ AxiomaticTheory["WolframAxioms", "NotableTheorems"][ "Commutativity"], AxiomaticTheory["WolframAxioms"]] |

✕
proof1["ProofGraph"] |

✕
proof1["ProofDataset"] |

Accordingly, the analogous perturbation to this geodesic has a more dramatic effect on its length (e.g. shortening it by a total of 3 steps rather than just 1):

✕
proof1["ProofDataset"][[3]]["Statement"] |

✕
proof2 = FindEquationalProof[ AxiomaticTheory["WolframAxioms", "NotableTheorems"][ "Commutativity"], Join[AxiomaticTheory[ "WolframAxioms"], {ForAll[{\[FormalA], \[FormalB], \[FormalC]}, proof1["ProofDataset"][[3]]["Statement"]]}]] |

✕
proof2["ProofGraph"] |

✕
{proof1["ProofGraph"], proof2["ProofGraph"]} |

In these proof graphs, each dashed line indicates where a previously proved result is being used in the proof of some future lemma, and so corresponds to the analog of a causal edge in an ordinary multiway system. Indeed, we can see the correspondence directly by first inspecting the sequence of causal edges as seen in an ordinary string multiway system

✕
ResourceFunction["MultiwaySystem"][{"A" -> "B", "B" -> "C", "C" -> "D", "D" -> "E", "E" -> "F"}, "A", 6, "EvolutionCausalGraph"] |

and then comparing against the sequence of dashed edges in the associated proof object representation:

✕
convertStringToOperator[string_String] := Module[{expression, list}, list = StringSplit[string, ""]; expression = list; While[Length[list] > 1, expression = expression /. list -> (CircleDot[ToExpression[First[list]], Rest[list]]); list = Rest[list]]; expression /. list -> ToExpression[First[list]]] Module[{theorems, axioms, stringTheorems, stringAxioms}, theorems = {"A" -> "F"}; axioms = {"A" -> "B", "B" -> "C", "C" -> "D", "D" -> "E", "E" -> "F"}; stringTheorems = (convertStringToOperator[First[#]] == convertStringToOperator[Last[#]]) & /@ theorems; stringAxioms = (convertStringToOperator[First[#]] == convertStringToOperator[Last[#]]) & /@ axioms; Evaluate[ FindEquationalProof[stringTheorems, Join[stringAxioms, {ForAll[{a, b, c}, CircleDot[a, CircleDot[b, c]] == CircleDot[CircleDot[a, b], c]]}]]] /. "EquationalLogic" -> "StringLogic"] |

✕
proof["ProofGraph"] |

Therefore, we may think of the presence of these dashed lines (and hence, of causal edges) as being an indication of the degree to which newly proved lemmas “build upon” previous results, which may, in turn, be interpreted as a crude measurement of the degree of mathematical abstraction used within the proof. In the conventional mathematical formulation of the Wolfram model, I also first proposed that the correct interpretation of the energy-momentum tensor is the flux of causal edges through a constant hypersurface in the causal graph (such that energy is flux through spacelike hypersurfaces, momentum is flux through timelike hypersurfaces, etc.).

The immediate corollary of these realizations is that the abstract analog of the energy-momentum tensor in spacetime should be a kind of “abstraction tensor” in the space of mathematical proofs, measuring the density of these causal edges. Furthermore, we can infer that a generalization of the Einstein field equations should hold within this space of all possible mathematical proofs, and that these equations will assert that the level of abstraction of the proof (i.e. our abstraction of the energy-momentum tensor) should be directly related to the density of critical pair lemmas (i.e. our approximation to the abstraction of the Ricci curvature, which is, correspondingly, a proxy to the computational difficulty of generating the proof).

Just as all relativistic observers with nonzero mass are required to lie strictly on the interior (and not on the boundary) of elementary light cones, so too are computationally bounded models required to lie strictly on the interior of elementary “proof cones”. For instance, all geodesics highlighted in red here constitute syntactically valid proofs of the proposition “AA” → ”ABBBBABBBB“ (since all are ultimately consistent with the induced partial order):

✕
mwGraph = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"]; allPaths = FindPath[mwGraph, "AA", "ABBBBABBBB", Infinity, All] |

✕
HighlightGraph[mwGraph, Subgraph[mwGraph, allPaths]] |

However, two of these proofs lie strictly on the boundary of the associated “proof cone”, and hence correspond to the analog of lightlike, rather than ordinary timelike, paths:

✕
lightlikePath1 = DeleteDuplicates[ Join[FindShortestPath[mwGraph, "AA", "AABBBB"], FindShortestPath[mwGraph, "AABBBB", "ABBBBABBBB"]]] |

✕
lightlikePath2 = DeleteDuplicates[ Join[FindShortestPath[mwGraph, "AA", "ABBBBA"], FindShortestPath[mwGraph, "ABBBBA", "ABBBBABBBB"]]] |

✕
HighlightGraph[mwGraph, {Subgraph[mwGraph, allPaths], Subgraph[mwGraph, lightlikePath1], Subgraph[mwGraph, lightlikePath2]}] |

Therefore, although these proofs (here highlighted in yellow and purple) are syntactically correct, they cannot be witnessed by any computationally bounded (i.e. “subluminal”) model. Thus, we can conclude that non-constructive proofs correspond to the analog of lightlike paths in the associated proof space. One immediate and amusing consequence of this correspondence is that the analog of the Penrose–Hawking singularity theorems would imply that, in the presence of sufficient “abstraction density” in proof space, proofs will inevitably become non-constructive (i.e. the analog of a black hole event horizon).

To be more precise, we can infer that certain axioms (such as the axiom of choice in ZFC set theory and the law of excluded middle in classical logic) that are known to permit non-constructive proofs of propositions can be thought of as inducing the formation of black holes in the space of mathematical proofs. On the surface of a black hole event horizon, there will exist pairs of points where the only geodesics connecting them correspond to lightlike paths. Similarly, in a system of mathematics based on non-constructive axioms, there will exist pairs of terms (i.e. propositions) where the only proofs connecting them are non-constructive, and so one would require effective hypercomputation (corresponding to a model “traveling” at the analog of the “speed of light”) in order to be able to witness them model-theoretically.

Another rather interesting implication of this formalism is that there should exist model-theoretic analogs of logical speedup theorems, which correspond to the analog of Lorentz transformations in proof space. For instance, the famous Gödel speedup theorem asserts that, in formal axiomatic systems that are at least as rich as Peano arithmetic, there will exist propositions whose shortest proofs are of arbitrary length, but that such proofs can always be made shorter (i.e. “sped up”) by working in a stronger axiomatic system. We can easily see this by constructing explicitly the statement “This statement is unprovable using fewer than *n* symbols.”, which, via Gödel numbering, can be encoded as an elementary statement in Peano arithmetic. Clearly, if Peano arithmetic is consistent, then the shortest proof of this statement must contain at least *n* symbols, but it is nevertheless trivial to prove in the stronger axiomatic system PA + Con(PA) (i.e. the Peano axioms, plus an additional axiom asserting the consistency of the Peano axioms).

Similarly, we see that we now have a model-theoretic version of the same idea; by shifting to a “boosted” foliation, we can reduce the computational effort necessary to verify a theorem (i.e. to confirm that a particular path is consistent with the total order induced by the model), which is the analog of relativistic time dilation, but the tradeoff is that more computational effort is required in order to verify the model (since there now exist more terms on each slice of the foliation, all of which must be confirmed as being valid anti-chains with respect to the partial order of the proof network, in order for the model to be verified as being consistent with the underlying axioms), which forms the analog of relativistic length contraction, as seen here:

✕
CloudGet["https://wolfr.am/KXgcRNRJ"] |

✕
{ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure", Epilog -> straightFoliationLines[{1, 0}, {0.4, 0}, # &, {0, 0}]], ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure", Epilog -> straightFoliationLines[{1, 0}, {0.8, 0}, # &, {0, 0}]]} |

As such, the “invariant spacetime interval” now becomes the effective difference between the time complexity of verifying the theorem and the time complexity of verifying the associated model, such that, by making a parameterized change of model, there can be “no free lunch” (any computational saving made in one verification task is offset by a computational loss made in the other task). For instance, as mathematicians continue to increase the level of mathematical abstraction of the field by proving more theorems, a “generalized graduate student” who is prepared to accept the validity of those theorems on faith is able to make faster progress than they would have done if the abstraction level had been lower, but the tradeoff is that the foundations of mathematics become harder to formally verify as a result. In particular, we therefore conclude that non-constructive proofs are ones whose associated models would require infinite computational power to verify, as we conjectured previously.

This entire correspondence rests upon an interpretation of “spacelike-separated” terms as being ones that are mutually independent of the underlying axioms (and therefore among which relations can be defined without contradicting the underlying theory). If we interpret the axioms as forming an orthonormal basis for the proof space, then these mutually independent terms become precisely the linearly independent vectors in that space (in other words, proof-theoretic independence becomes linear independence). We can see how this analogy works explicitly by considering the particular example of finite presentation theory on generic algebraic structures, as we do subsequently.

Consider the pair of highlighted terms in the following multiway proof network:

✕
HighlightGraph[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], {"ABBA", "AABBB"}] |

Since they are not comparable within the partial order defined by the proof network (i.e. since they form an anti-chain), the associated proposition may be considered to be independent of the underlying axiom system, as discussed previously. If we add an additional proposition asserting the equivalence of these terms, then, in the absence of any further relations, we will obtain something akin to the following (inertial) foliation:

✕
HighlightGraph[ ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure", Epilog -> straightFoliationLines[{1, 0}, {0.1, 0}, # &, {0, 0}]], {"ABBA", "AABBB"}] |

In other words, we see here a flat foliation in which the proposition is semantically true, since “ABBA” immediately precedes “AABBB” in the total order induced by that foliation choice. The addition of this relation then implies further relations between terms, which is why the foliation lines are extrapolated out to cover the entirety of proof space; if further relations were to be explicitly enforced, then we would obtain a more arbitrary (non-flat, non-inertial) foliation choice, as we showed before.

To see more directly how this works, consider the case of the finite presentation theory for simple algebraic structures. Note that we can represent generators for algebraic structures as unidirectional multiway rules like “A” → “AB”, and that the associativity of any such structure is enforced by the natural associativity of the concatenation operator for strings. Therefore, by examining the following multiway system

✕
generators = {"A" -> "AA", "A" -> "AB", "B" -> "BA", "B" -> "BB"}; ResourceFunction["MultiwaySystem"][generators, {"A", "B"}, 3, "StatesGraph"] |

we see that we naturally obtain the finitely presented semigroup with two generators, “A” and “B”. One could argue that strings more typically form a monoid, since the empty string `""` constitutes a natural choice of identity element, but let’s choose instead to specify the identity element more explicitly as “E”, thus yielding the following finitely presented monoid:

✕
generators = {"A" -> "AA", "A" -> "AB", "A" -> "AE", "B" -> "BA", "B" -> "BB", "B" -> "BE", "E" -> "EA", "E" -> "EB", "E" -> "EE"}; identityAxiom = {"AE" -> "A", "EA" -> "A", "BE" -> "B", "EB" -> "B", "EE" -> "E"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom], {"A", "B", "E"}, 2, "StatesGraph"] |

Further specifying inverse elements “X” and “Y” for “A” and “B”, respectively, yields a finitely presented group:

✕
generators = {"A" -> "AA", "A" -> "AB", "A" -> "AE", "A" -> "AX", "A" -> "AY", "B" -> "BA", "B" -> "BB", "B" -> "BE", "B" -> "BX", "B" -> "BY", "E" -> "EA", "E" -> "EB", "E" -> "EE", "E" -> "EX", "E" -> "EY", "X" -> "XA", "X" -> "XB", "X" -> "XE", "X" -> "XX", "X" -> "XY", "Y" -> "YA", "Y" -> "YB", "Y" -> "YE", "Y" -> "YX", "Y" -> "YY"}; identityAxiom = {"AE" -> "A", "EA" -> "A", "BE" -> "B", "EB" -> "B", "EE" -> "E", "XE" -> "X", "EX" -> "X", "YE" -> "Y", "EY" -> "Y"}; inverseAxiom = {"AX" -> "E", "XA" -> "E", "BY" -> "E", "YB" -> "E"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom], {"A", "B", "E", "X", "Y"}, 2, "StatesGraph"] |

This multiway system consequently designates the free group on generators “A” and “B”—the group is free in the sense that it does not obey any additional relations beyond those necessitated by the group actions themselves, and its “freedom” can be seen directly from the fact that the associated network has four essentially independent “branches” (one for each of the elements “A”, “B”, “X” and “Y”). It is important to note that these multiway systems are not Cayley graphs, since they contain strictly more information: Cayley graphs solve the word problem implicitly (e.g. if “E” is the identity element, then there is no vertex “EAE” in a Cayley graph—there is only “A”), whereas in one of these multiway models there is an explicit path demonstrating the solution of the word problem directly, e.g. “EAE” → “AE” → “A” etc. Since each edge corresponds directly to the application of a group axiom, a generator or a relation, these multiway systems are thus much closer to the underlying structure of the group axioms than a Cayley graph otherwise would be.

As an illustrative example, we could now force elements “A” and “B” to commute with one another by incorporating the additional relation “AB” == “BA”:

✕
commutativityRelation1 = {"AB" -> "BA", "BA" -> "AB"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom, commutativityRelation1], {"A", "B", "E", "X", "Y"}, 2, "StatesGraph"] |

Note that, within this scheme, generators are specified using unidirectional rules such as “A” → “AB”, whereas relations are specified using bidirectional rules such as “AB” ↔ “BA”. Unsurprisingly, the inclusion of such a relation has the effect of “binding” the two branches corresponding to elements “A” and “B” together, thus causing them to act as a single effective branch (since there is now a pair of rules that allows one to “jump” easily from one branch to another). In other words, the inclusion of this relation is equivalent to performing a critical pair completion on the associated branches, or, alternatively, to inducing a foliation on the multiway system (since the set of elements within which one is imposing equivalences in the context of a critical pair completion can equally well be thought of as being the set of elements within the level surface of some multiway foliation). Forcing commutativity of “X” and “Y” through the relation “XY”==“YX” has the same effect of binding the “X” and “Y” branches together:

✕
commutativityRelation2 = {"XY" -> "YX", "YX" -> "XY"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom, commutativityRelation1, commutativityRelation2], {"A", "B", "E", "X", "Y"}, 2, "StatesGraph"] |

As one might reasonably expect, adding relations to enforce commutativity among all elements is equivalent to imposing an axiom of commutativity at a purely proof-theoretic level, and so the resulting multiway structure is isomorphic to that of an ordinary abelian group, in which all branches essentially collapse down to form a single branch:

✕
commutativityAxiom = {"AB" -> "BA", "AE" -> "EA", "AX" -> "XA", "AY" -> "YA", "BA" -> "AB", "BE" -> "EB", "BX" -> "XB", "BY" -> "YB", "EA" -> "AE", "EB" -> "BE", "EX" -> "XE", "EY" -> "YE", "XA" -> "AX", "XB" -> "BX", "XE" -> "EX", "XY" -> "YX", "YA" -> "AY", "YB" -> "BY", "YE" -> "EY", "YX" -> "XY"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom, commutativityAxiom], {"A", "B", "E", "X", "Y"}, 2, "StatesGraph"] |

To take a slightly more subtle example, imagine instead imposing the relations “A”==“Y”, “B”==“X” (in other words, explicitly declaring that “A” is the inverse of “B”, and vice versa). The resultant multiway structure is

✕
inverseRelation = {"A" -> "Y", "Y" -> "A", "B" -> "X", "X" -> "B"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom, inverseRelation], {"A", "B", "E", "X", "Y"}, 2, "StatesGraph"] |

which we can see is ultimately just a more “decorated” version of the multiway structure for the free group generated by a single element “A”, with a single inverse “X”:

✕
generators = {"A" -> "AA", "A" -> "AE", "A" -> "AX", "E" -> "EA", "E" -> "EE", "E" -> "EX", "X" -> "XA", "X" -> "XE", "X" -> "XX"}; identityAxiom = {"AE" -> "A", "EA" -> "A", "XE" -> "X", "EX" -> "X"}; inverseAxiom = {"AX" -> "E", "XA" -> "E"}; ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom], {"A", "E", "X"}, 2, "StatesGraph"] |

As such, a Knuth–Bendix completion applied to a multiway system corresponding to the free group on two generators can therefore be interpreted as applying all possible sets of relations

✕
generators = {"A" -> "AA", "A" -> "AB", "A" -> "AE", "A" -> "AX", "A" -> "AY", "B" -> "BA", "B" -> "BB", "B" -> "BE", "B" -> "BX", "B" -> "BY", "E" -> "EA", "E" -> "EB", "E" -> "EE", "E" -> "EX", "E" -> "EY", "X" -> "XA", "X" -> "XB", "X" -> "XE", "X" -> "XX", "X" -> "XY", "Y" -> "YA", "Y" -> "YB", "Y" -> "YE", "Y" -> "YX", "Y" -> "YY"}; identityAxiom = {"AE" -> "A", "EA" -> "A", "BE" -> "B", "EB" -> "B", "EE" -> "E", "XE" -> "X", "EX" -> "X", "YE" -> "Y", "EY" -> "Y"}; inverseAxiom = {"AX" -> "E", "XA" -> "E", "BY" -> "E", "YB" -> "E"}; completionRules = ResourceFunction["CanonicalKnuthBendixCompletion"][ Join[generators, identityAxiom, inverseAxiom]] |

and consequently generating the “maximally non-free” group structure:

✕
mwGraph = ResourceFunction["MultiwaySystem"][ Join[generators, identityAxiom, inverseAxiom, completionRules], {"A", "B", "E", "X", "Y"}, 2, "StatesGraphStructure"] |

As an illustration of its “maximal non-freeness”, we can for instance see explicitly that this structure (which one can think of as being effectively the rulial space of all groups with two generators) exhibits, for instance, commutativity of elements “A” and “B”:

✕
FindShortestPath[mwGraph, "AB", "BA"] |

And, being a rulial space, it follows that all other groups on two generators can be constructed via an appropriate fibration of this “maximally non-free” group structure, as we shall now try to demonstrate. Due to the correspondence between completion procedures in the context of imposing group relations and completion procedures in the context of performing quantum measurements, we can therefore think of the free group as being a “purely quantum mechanical” group structure, while the maximally non-free group is a “purely classical” group structure, with all other groups lying somewhere on the intermediate spectrum.

I first developed the function `MultiwayTuringMachine` (as used in Stephen’s recent bulletin on exploring rulial space in the case of Turing machines) as a means of visualizing the evolution of arbitrary nondeterministic Turing machines using our multiway system framework; for instance, we can visualize the evolution of the 2-state, 2-color nondeterministic Turing machine constructed from deterministic Turing machine rules 100 and 150 as follows:

✕
ResourceFunction["MultiwayTuringMachine"][{100, 150}, {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 4, "StatesGraph", VertexSize -> 1] |

After more evolution steps, we begin to see the following emergent structure in the states graph:

✕
mwGraph = ResourceFunction["MultiwayTuringMachine"][{100, 150}, {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 7, "StatesGraphStructure"] |

One rather elegant ancillary benefit of the `MultiwayTuringMachine` functionality is its ability to produce visualizations of rulial space with ease, by simply constructing a multiway evolution from the application of all possible deterministic Turing machine rules of a particular size. For instance, we can visualize the rulial space of all 2-state, 2-color Turing machine rules ranging from 1 to 200 as follows:

✕
rulialGraph = ResourceFunction["MultiwayTuringMachine"][ Range[1, 200], {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 7, "StatesGraphStructure"] |

As discussed earlier, the rulial multiway system (which, within this new context, we may think of as being the structure that one obtains by starting from a particular multiway system and applying all possible completion rules, or equivalently by inducing all possible homotopies between paths), is naturally endowed with the structure of an infinity-topos, allowing us to localize by converting collections of morphisms into isomorphisms. We can do this because the rulial multiway system invokes all possible rules of a particular size, so if there exists a rule mapping state A to state B, then there will always necessarily exist another rule mapping state B back to state A etc. This realization makes it very natural to conjecture that the rulial topos can be “fibrated” in such a way that every particular multiway system corresponds to a particular “fiber” of rulial space in some fairly precise sense. For instance, the multiway system associated with the {100, 150} nondeterministic Turing machine shown previously would correspond to the fiber shown in red here:

✕
HighlightGraph[rulialGraph, mwGraph] |

In ordinary topology, a “fibration” is a way of making precise the notion that it is possible to parameterize one topological space (known as a “fiber”) in terms of another topological space (known as a “base space”). In the more restricted “fiber bundle” construction, every fiber needs to be a copy of the exact same topological space (or, at the very least, the fibers must all be homeomorphic), but in the more general case of an arbitrary fibration, the only condition is that each pair of fibers be “homotopy-equivalent”, meaning that there must exist continuous maps from one fiber to the other such that the composition of those maps is homotopic to the identity map on the corresponding fiber. In particular, in order to demonstrate that the construction described is indeed a valid fibration in the topological sense, we must proceed to demonstrate that it satisfies the so-called “homotopy lifting property”.

In an ordinary fiber bundle, the “connection” is a rule for “lifting” an elementary step in the base space up to a corresponding elementary step in the fiber; thus, in our context, where each particular multiway system is interpreted as a base space, and the subgraph of the overall rulial multiway system that corresponds to that particular multiway system is interpreted as the corresponding fiber, our “connection” is the rule that allows one to map edges in the ordinary multiway system to the corresponding edges in the rulial multiway system. The “homotopy lifting property” is thus the property that any homotopies in the base space will naturally be “lifted up” by the connection to homotopies in the corresponding fiber. To see how this works directly, consider the following pair of paths in our original (nondeterministic Turing machine) multiway system:

✕
path1 = FindShortestPath[mwGraph, ToString[{{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}], ToString[{{1, 8, -1}, {1, 1, 0, 0, 1, 0, 0, 0, 0}}]] |

✕
path2 = FindShortestPath[mwGraph, ToString[{{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}], ToString[{{1, 8, -1}, {1, 1, 1, 0, 1, 0, 0, 0, 1}}]] |

✕
HighlightGraph[mwGraph, {Subgraph[mwGraph, path1], Subgraph[mwGraph, path2]}] |

We can now proceed to define a homotopy between these paths in the usual way:

✕
homotopy = Join[Thread[path1 -> path2], Thread[path2 -> path1]] |

✕
HighlightGraph[ GraphUnion[mwGraph, Graph[homotopy]], {Subgraph[mwGraph, path1], Subgraph[mwGraph, path2], homotopy}] |

The homotopy lifting property will be satisfied (and, consequently, our interpretation of the ordinary multiway system as being the base space for an associated fiber in the rulial multiway system will be formally justified) if and only if for every such homotopy between pairs of paths the homotopy is “lifted” by the connection to form a valid homotopy in the rulial multiway system as well—a fact which we can now make manifest:

✕
HighlightGraph[ GraphUnion[rulialGraph, Graph[homotopy]], {Subgraph[rulialGraph, path1], Subgraph[rulialGraph, path2], homotopy}] |

This interpretation of ordinary multiway systems as being the fibers of some rulial topos, when combined with Grothendieck’s hypothesis, therefore explains not only why so many discretely defined mathematical structures (like groups, rings, algebras, lattices, etc.) come naturally associated with a notion of a continuous spatial structure (such a differentiable manifold for a Lie group, a topological space for a topological group, a collection of clopen subsets of a topological space for a Boolean algebra, etc.), as explained by Shulman’s synthetic topology and cohesive geometry programs. Indeed, in this context, it suffices to treat Grothendieck’s hypothesis less as a hypothesis and more as an abstract definition of what it means to be a topological space (i.e. anything with an infinity-groupoid structure). It also explains why our discretely defined physical structures (such as hypergraphs, causal graphs, multiway graphs, etc.) also come naturally associated with a continuous spatial structure (such as a Riemannian manifold for a hypergraph, a Lorentzian manifold for a causal graph, a projective Hilbert space for a branchial graph, [conjecturally] a twistor correspondence space for a multiway causal graph, etc.)

At some ultimate level, all of these objects are simply inheriting their topology and geometry from that of the rulial multiway system, and its natural infinity-topos structure; the rulial multiway system endows its fibers (the ordinary multiway causal graphs) with the spatial structure of (conjecturally!) a twistor correspondence space. These multiway systems then endow their hypersurfaces (the branchial graphs) with the spatial structure of a projective Hilbert space, and also endow their fibrations (the ordinary spacetime causal graphs) with the spatial structure of a Lorentzian manifold; these spacetime causal graphs in turn endow their hypersurfaces (the spatial hypergraphs) with the spatial structure of a Riemannian manifold, etc.

So does anything exciting happen when we choose to “descend down” from the geometry of the full rulial topos to the rather more mundane geometry of a particular multiway system (of the kind that we conventionally use in our descriptions of quantum mechanics)? Well, as it turns out, the answer seems to be yes…

Categorical quantum mechanics, as pioneered by Samson Abramsky and Bob Coecke, aims to define a relatively weak set of axiomatic constraints (for instance, much weaker than the usual Hilbert space axioms used in the standard operator-theoretic formulations of quantum mechanics) that can nevertheless reproduce the salient features of key quantum phenomena; its basic setting is a so-called “dagger symmetric monoidal category”. A “monoidal category” is a category equipped with an additional associative “bifunctor” (i.e. a map from a pair of categories down to a single category), mapping the product of the category with itself onto itself, that can be interpreted as an additional tensor product structure on that category, along with an element that acts as both a left and right identity for this tensor product bifunctor (where associativity and identity are enforced only up to natural isomorphism). A “symmetric monoidal category” is hence a monoidal category in which the tensor product bifunctor is “as symmetric as possible”, in the sense that the tensor product of *A* and *B* is naturally isomorphic to the tensor product of *B* and *A*. Finally, a “dagger symmetric monoidal category” is a symmetric monoidal category equipped with an additional involutive “dagger structure”, whose significance we shall discuss momentarily.

Arsiwalla subsequently observed that, with an appropriate interpretation of the tensor product type constructor, Abramsky and Coecke’s formulation of categorical quantum mechanics is precisely the formulation that we obtain upon foliating the rulial multiway system to obtain ordinary (quantum mechanical) multiway systems. More specifically, a particular multiway (nondeterministic) Turing machine, such as the one generated by deterministic 2-state, 2-color Turing machine rules 100, 150 and 200

✕
ResourceFunction["MultiwayTuringMachine"][{100, 150, 200}, {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 4, "StatesGraphStructure"] |

will exhibit a particular branchial graph structure upon appropriate foliation into branchlike hypersurfaces, which in this specific case happens to correspond to the rather simple pattern of disconnected triangular graph components shown here:

✕
multiwayBranchialGraph = ResourceFunction["MultiwayTuringMachine"][{100, 150, 200}, {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 4, "BranchialGraphStructure"] |

On the other hand, the rulial multiway system, such as the one generated by deterministic Turing machine rules 1 to 300

✕
ResourceFunction["MultiwayTuringMachine"][ Range[1, 300], {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 4, "StatesGraphStructure"] |

being naturally a much richer combinatorial structure, will in general produce a much more complicated branchial graph structure upon foliation into rulelike hypersurfaces:

✕
rulialBranchialGraph = ResourceFunction["MultiwayTuringMachine"][ Range[1, 300], {{1, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0, 0}}, 4, "BranchialGraphStructure", EdgeStyle -> ResourceFunction["WolframPhysicsProjectStyleData"]["RulialGraph"][ "EdgeStyle"]] |

However, because the multiway graph itself corresponds to the base space for a particular fiber in the associated rulial multiway graph, we can consequently highlight where the triangles in the branchial graph structure for the ordinary multiway system have been “embedded” into the branchial graph structure for the overall rulial multiway system, as follows:

✕
HighlightGraph[rulialBranchialGraph, multiwayBranchialGraph] |

So the obvious question now becomes: since the rulial multiway system is essentially constructed via a concatenation of all possible multiway rules, can we consequently interpret the rulial branchial graphs as corresponding to some generalized tensor product of all possible multiway branchial graphs? In other words, is a tensor product in branchial space simply a concatenation operation of rules in rulial space?

More work is required in order to make this correspondence mathematically rigorous (as we shall demonstrate in our forthcoming paper), but I shall give here a plausibility argument instead. The tensor product operation is characterized by a universal property of being the maximally free bilinear operation; loosely speaking, it is the most general bilinear operation (i.e. the most general operation mapping a product of vector spaces to a vector space, in such a way as to be linear in each of its arguments) that “behaves like a multiplication operation should behave”.

Take, as an illustrative example, the following pair of (isomorphic) multiway systems:

✕
{mwGraph1 = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "StatesGraphStructure"], mwGraph2 = ResourceFunction["MultiwaySystem"]["A" -> "BA", "AA", 8, "StatesGraphStructure"]} |

Upon foliation, these yield the following pair of path-like branchial graphs, which we may interpret as corresponding to simple one-dimensional vector spaces:

✕
{branchialGraph1 = ResourceFunction["MultiwaySystem"]["A" -> "AB", "AA", 8, "BranchialGraphStructure"], branchialGraph2 = ResourceFunction["MultiwaySystem"]["A" -> "BA", "AA", 8, "BranchialGraphStructure"]} |

By concatenating the associated multiway rules together, we obtain a kind of “reduced” rulial multiway system with a somewhat more intricate structure

✕
rulialGraph = ResourceFunction["MultiwaySystem"][{"A" -> "AB", "A" -> "BA"}, "AA", 8, "StatesGraphStructure"] |

yet one where the fibers associated with the original two multiway graphs are still easily discernible:

✕
HighlightGraph[rulialGraph, {mwGraph1, mwGraph2}] |

Likewise, upon foliation of the reduced rulial multiway graph, the branchial graphs now form a two-dimensional vector space structure

✕
rulialBranchialGraph = ResourceFunction["MultiwaySystem"][{"A" -> "AB", "A" -> "BA"}, "AA", 8, "BranchialGraphStructure"] |

yet the original one-dimensional vector spaces involved in the tensor product can be identified as essentially forming the spanning set of this higher-dimensional space:

✕
HighlightGraph[rulialBranchialGraph, {branchialGraph1, branchialGraph2}] |

Therefore, exactly as Arsiwalla had conjectured, the object obtained by foliation of the rulial multiway graph does indeed have a category-like structure, equipped with an additional “tensor product–like” bifunctor, whose associativity and commutativity (up to isomorphism) are guaranteed by the trivial associativity and commutativity of rule concatenation in multiway systems—or, in other words, we get exactly a symmetric monoidal category. This gives us a new, and much more eminently categorical, way of thinking about the formulation of quantum mechanics within our formalism, since now the branchial structure obtained through any foliation of the overall rulial multiway graph into ordinary multiway systems will necessarily correspond to a tensor product of (potentially finite-dimensional) Hilbert spaces, just as one would expect from the foundations of “ordinary” quantum mechanics. There is also much more to discuss here regarding this new interpretation of the tensor product operation in monoidal categories as being essentially a joining operation on type constructors, and the various algebraic and geometrical implications that it has.

One immediate, and rather interesting, implication this new interpretation entails is that the fibrations we were constructing before, which essentially allowed us to “split” a rulial multiway system into its constituent ordinary multiway systems, can be thought of as corresponding to a kind of generalized partial trace operation. This, in turn, provides further formal justification for our present interpretation of branchial graphs as being effective “graphs of entanglement” between microstates of the universe (i.e. graphs in which each vertex corresponds to a microstate, and in which the natural combinatorial distance metric on the graph corresponds to a measure of entanglement entropy), because now we can see explicitly that if a pair of microstates are “entangled” (i.e. if they are connected by a branchial edge), then any fibration that attempts to separate them will necessarily lose the information associated with that branchial edge. This corresponds precisely to the statement in ordinary quantum mechanics that any attempt to partially trace out one subsystem from a pair of entangled subsystems will necessarily cause the state to lose purity etc.

I mentioned previously that I would return to the remaining issue of the origins of the dagger structure in these models. The “dagger” in the dagger symmetric monoidal categories of categorical quantum mechanics is an additional structure that the monoidal category is equipped with that acts as an “involutive” functor (i.e. a functor that constitutes its own inverse operation), with the broad intuition being that the dagger operation corresponds to some appropriate generalization of the Hermitian adjoint operation from ordinary functional analysis, and hence can be used to define the appropriate generalizations of self-adjoint and unitary operators in categorical quantum mechanics. Of course, there are many possible choices of involutive functorial transformations that one could conceivably apply to a branchial graph (for instance, the reversal of a particular subset of directed branchial edges would be perhaps the most obvious example), but identifying which *particular* involutive transformation yields the most appropriate interpretation of the dagger structure within our models will require further work.

Indeed, the realizations discussed in this bulletin potentially give us a new insight into *why* the laws of both quantum mechanics and general relativity *are actually true*. As we have seen, the fact that the infinite limits of the combinatorial structures associated with causal graphs correspond to Lorentzian manifolds (for which, as I proved formally in the context of our models, the most general set of constraints needed to guarantee this limit correspond exactly to the Einstein field equations of ordinary general relativity) is guaranteed by Grothendieck’s hypothesis and the inheritance of spatial structure from fibrations of the rulial topos. But now, we see also that a symmetric monoidal category–like structure, and hence the entire formalism of categorical quantum mechanics, is also an inevitable feature arising from *foliations* of this exact same topos. And, as we have now established, the univalence axiom is precisely the assumption that allows us to transform these foliations into fibrations and back again (and hence, it is ultimately univalence that guarantees the logical consistency between quantum mechanics and general relativity in the context of our formalism, and demonstrates that both theories are really just different manifestations of the same fundamental principle of causal invariance). Thus, for the first time, we perhaps begin to glimpse not just what the laws of physics *are*, but also why the laws of physics (and, indeed, of mathematics) *must be so*.

- Complete the writeup of the supplementary mathematical paper to this bulletin.
- Work to obtain a better understanding of the potential origins of the involutive dagger structure in foliations of the rulial multiway system, and its implications for the foundations of quantum mechanics.
- Develop efficient code for converting neatly between multiway systems and proof objects.
- Perform a systematic experimental study of mathematical proofs generated using
`FindEquationalProof`, in an attempt to determine empirically the form of the generalized “Einstein field equations” in the space of possible mathematical proofs (i.e. the quantitative relationship between the density of critical pair lemmas and the density of causal edges, as projected in particular directions). - Determine the nature and interpretation of topological obstructions in the space of all possible mathematical proofs (my personal conjecture: at least when viewed as a rulial space, these obstructions will correspond to the analog of NP-complete problems that prevent one from performing the analogs of polynomial-time reductions between models/complexity classes).
- Investigate hypergraphs as a potentially appropriate formalism for representing “thickened” branchial graphs (i.e. branchial graphs in which state ancestry goes back further than a single evolution edge), and the possibility of thus obtaining an abstract generalization of categorical quantum mechanics.

We recently wrapped up the four weeks of our first-ever “Physics track” Wolfram Summer School---and the results were spectacular! More than 30 projects potentially destined to turn into academic papers---reporting all kinds of progress on the Wolfram Physics Project.

When we launched the Wolfram Physics Project just three months ago one of the things I was looking forward to was seeing other people begin to seriously contribute to the project. Well, it turns out I didn't have to wait long! Because---despite the pandemic and everything---things are already very much off and running!

Six weeks ago we made a list of questions we thought we were ready to explore in the Wolfram Physics Project. And in the past five weeks I'm excited to say that through projects at the Summer School lots of these are already well on their way to being answered. If we ever wondered whether there was a way for physicists (and physics students) to get involved in the project, we can now give a resounding answer, "yes".]]>

We recently wrapped up the four weeks of our first-ever “Physics track” Wolfram Summer School---and the results were spectacular! More than 30 projects potentially destined to turn into academic papers---reporting all kinds of progress on the Wolfram Physics Project.

When we launched the Wolfram Physics Project just three months ago one of the things I was looking forward to was seeing other people begin to seriously contribute to the project. Well, it turns out I didn't have to wait long! Because---despite the pandemic and everything---things are already very much off and running!

Six weeks ago we made a list of questions we thought we were ready to explore in the Wolfram Physics Project. And in the past five weeks I'm excited to say that through projects at the Summer School lots of these are already well on their way to being answered. If we ever wondered whether there was a way for physicists (and physics students) to get involved in the project, we can now give a resounding answer, "yes".]]>