# The Case of Simple Multiway Systems

### A Minimal Instance of Multicomputation

Multicomputation is an important new paradigm, however one that may be fairly obscure. Right here my objective is to debate a minimal instance: multiway programs based mostly on numbers. Many common multicomputational phenomena will present up right here in easy kinds (although others won’t). And the involvement of numbers will usually enable us to make fast use of conventional mathematical strategies.

A multiway system can be described as taking every of its states and repeatedly changing it based on some rule or guidelines with a group of states, merging any states produced which can be equivalent. In our Physics Project, the states are combinations of relations between elements, represented by hypergraphs. We’ve additionally usually thought of string substitution systems, through which the states are strings of characters. However right here I’ll think about the case through which the states are numbers, and for now simply single integers.

And on this case multiway programs may be represented in a very easy method, with every state *s* simply being repeatedly changed based on:

*s* → (*s*), … , }

For a “binary branching” case the replace rule is

and one can signify the evolution of the system by the multiway graph which begins:

and continues (indicating by purple and by blue):

With arbitrary “symbolic” this (“free multiway system”) tree is the one construction one can get. However issues can get a lot much less trivial when there are kinds for , that “consider” ultimately, as a result of then there may be identities that make branches merge. And certainly most of what we’ll be discussing right here is related to this phenomenon and with the “entanglements” between states to which it leads.

It’s price noting that the particular setup we’re utilizing right here avoids various the structural complexity that may exist in multicomputational programs. In the general case, states can contain multiple “tokens”, and updates can even “eat” a number of tokens. In our case right here, every state simply comprises one token—which is a single quantity—and that is what’s “consumed” at every step. (In our Physics Undertaking, a state corresponds to a hyperedge which comprises many hyperedge tokens, and the replace rule sometimes consumes a number of hyperedges. In a string substitution system, a state is a personality string which comprises many character tokens, and the replace sometimes consumes a number of—on this case, adjoining—character tokens.)

With the setup we’re utilizing right here there’s one enter however a number of outputs (2 within the instance above) every time the replace rule is utilized (with the inputs and outputs every being particular person numbers). It’s additionally completely doable to contemplate instances through which there are a number of inputs in addition to a number of outputs. However right here we’ll limit ourselves to the “one-to-many” (“conventional multiway”) case. And it’s notable that this case is exceptionally simple to explain within the Wolfram Language:

## Multiway Programs Based mostly on Addition

As our first instance, let’s think about multiway programs whose guidelines simply contain addition.

The trivial (“one-input, one-output”) rule

offers a multiway graph equivalent to a “one-way quantity line”:

The rule

offers a “two-way quantity line”:

However even

offers a barely extra sophisticated multiway graph:

What’s happening right here? Principally every triangle represents an id. For instance, ranging from 1, making use of twice offers 3, which is similar outcome as making use of as soon as. Or, writing the rule within the type

the triangles are all the results of the truth that on this case

For the “quantity line” rule, it’s apparent that we’ll finally go to each integer—and the +1, +2 rule additionally visits each integer.

Take into account now as a substitute of +1 and +2 the case of +2 and +3:

After just a few steps this offers:

Persevering with somewhat longer offers:

It’s somewhat troublesome to see what’s happening right here. It helps to indicate which edges correspond to +2 and +3:

We’ll return to this somewhat later, however as soon as once more we will see that there are cycles on this graph, equivalent to easy “commutativity identities”, resembling

and

in addition to “LCM identities” resembling

(Notice that on this case, all integers above 1 are finally generated.)

Let’s look now at a case with barely bigger integers:

After 6 steps one will get a easy grid

primarily made up of “commutativity identities”. However persevering with somewhat longer one sees that it begins to “wrap round”

finally forming a sort of “tube” with a spiral grid on the surface:

The “grid” is outlined by “commutativity identities”. However the purpose it’s a “closed tube” is that there are additionally “LCM identities”. To know this, unravel the whole lot right into a grid with +4 and +7 instructions—then draw strains between the duplicated numbers:

The “tube” is fashioned by rolling the grid up in such a method as to merge these numbers. However now if we assume that the multiway graph is laid out (in 3D) so that every graph edge has unit size, utility of Pythagoras’s theorem within the image above exhibits that the efficient circumference of the tube is .

In one other illustration, we will unravel the tube by plotting numbers at {*x*, *y*} based on their decomposition within the type :

(From this illustration we will see that each worth of *n* may be reached as long as .)

For the rule

the multiway graph kinds a tube of circumference which may be visualized in 3D as:

And what’s notable right here is that though we’re simply following a easy discrete arithmetic course of, we’re one way or the other “inevitably getting geometry” out of it. It’s a tiny, toy instance of a way more general and powerful phenomenon that appears to be ubiquitous in multicomputational programs—and that in our fashions of physics is principally what results in the emergence of issues just like the limiting continuum construction of area.

We’ve seen just a few particular instance of “multiway addition programs”. What concerning the extra common case?

For

a “tube” is generated with circumference

the place = {*a*, *b*}/`GCD`[*a*, *b*]

After sufficient steps, all integers of the shape *okay* `GCD`[*a*, *b*] will finally be produced—which implies that all integers are produced if *a* and *b* are comparatively prime. There’s at all times a threshold, nonetheless, given by `FrobeniusNumber`[{*a*, *b*}]—which for *a* and *b* comparatively prime is simply *a* *b* – *a* – *b*.

By the best way, a specific quantity *n*—if it’s going to be generated in any respect—will first be generated at step

(Notice that the truth that the multiway graph approximates a finite-radius tube is a consequence of the commensurability of any integers *a* and *b*. If we had a rule like , we’d get an infinite 2D grid.)

For

a tube is once more fashioned, with a circumference successfully decided by the smaller pair (after GCD discount) of *a*, *b* and *c*. And if `GCD`[*a*, *b*, *c*] = 1, all numbers above `FrobeniusNumber`[{*a*, *b*, *c*}] will finally be generated.

## Pure Multiplication

One of many easiest instances of multiway programs are these based mostly on pure multiplication. An instance is (now ranging from 1 reasonably than 0):

Usually, for

we’ll get a easy 2D grid every time *a* and *b* aren’t each powers of the identical quantity. With *d* components within the rule we’ll get a *d*-dimensional grid. For instance,

offers a 3D grid:

If the multipliers within the rule are all powers of the identical quantity, the multiway graph degenerates to some sort of ladder. Within the case

that is simply:

whereas for

it’s

and on the whole for

it’s a “width-*m*” ladder graph.

## Multiplication and Addition: n ⟼ {a n, n + b}

Let’s look now at combining multiplication and addition—to type what we’d name affine multiway programs. As a primary instance, think about the case (which I really already mentioned in *A New Kind of Science*):

Contemplating the simplicity of the rule by which it was generated, this outcome appears surprisingly advanced. One fast result’s that after *t* steps, the full variety of distinct numbers reached is `Fibonacci`[*t *– 1], which will increase exponentially like . Ultimately the ensures that each integer is generated. However the usually “jumps forward”, and because the most quantity generated at step *t* is the “common density” of numbers falls exponentially like .

Persevering with the evolution additional and utilizing a unique rendering we get the very “geometrical” (planar) construction

What can we are saying about this construction? Aside from the primary few steps (rendered on the heart), it consists of a spiral of pentagons. Every pentagon (besides the one on the heart) has the shape

reflecting the relation

Going out from the middle, every successive layer within the spiral has twice the variety of pentagons, with every pentagon at a given layer “spawning” two new pentagons on the subsequent layer.

Eradicating “incomplete pentagons” this may be rendered as:

What about different guidelines of the final type:

Listed here are the corresponding (“full polygon”) outcomes for by way of 5:

The multiway graphs in these instances correspond to spirals of ()-gons outlined by the id

or equivalently

At successive layers within the spiral, the variety of ()-gons will increase like .

Ultimately the evolution of the system generates all doable integers, however at step *t* the variety of distinct integers obtained to this point is given by the generalized Fibonacci collection obtained from

which for big *t* is

the place is the *k*-nacci generalized golden ratio, which approaches for big *okay*.

If we think about

it seems that one will get the identical fundamental construction (with ()-gons) for as for . For instance, with

one will get:

## The Rule *n* ⟼ {2*n* + 1, 3*n* + 1}

For the rule

there are at first no equivalences that trigger merging within the multiway graph:

However after 5 steps we get

the place now we see that 15 and 31 are linked “throughout branches”.

After 10 steps this turns into:

At a visible degree this appears to include two fundamental parts. First, a group of loops, and second a group of tree-like “free ends”. Preserving solely full loops and going just a few extra steps we get:

In contrast to in earlier instances, the “loops” (AKA “polygons”) will not be of fixed dimension. Listed here are the primary few that happen (word these loops “overlap” within the sense that a number of “begin the identical method”):

As earlier than, every of those loops in impact corresponds to an id about compositions of capabilities—although now it issues what these compositions are utilized to. So, for instance, the 4^{th} loop above corresponds to (the place *okay* stands for the perform ):

In express type this turns into:

the place each side consider to the identical quantity, on this case 26815.

A lot as within the Physics Undertaking, we will consider every “loop” as starting with the creation of a “branch pair”, and ending with the merger of the totally different paths from every member of the pair. In a later part we’ll talk about the query of whether or not each department pair at all times ultimately re-merges. However for now we will simply enumerate mergers—and we discover that the primary few happen at:

(Notice {that a} merger can by no means contain greater than two branches, since any given quantity has at most one “pre-image” beneath and one beneath .)

Here’s a plot of the positions of the mergers—along with a quadratic match (indicated by the dotted line):

(As we’ll talk about later, the numbers at which these mergers happen are for instance at all times of the shape .)

Taking second variations signifies a sure obvious randomness:

What can we are saying concerning the general construction of the multiway graph? One fundamental query is what numbers ever even happen within the evolution of the system. Listed here are the primary few, for evolution ranging from 0:

And listed here are successive variations

Dividing successive *m* by the quantity offers a progressive estimate of the density of numbers:

On a log-log scale this turns into

displaying a tough match to —and suggesting an asymptotic density of 0.

Notice, by the best way, that whereas the utmost hole grows on common linearly (roughly like 0.17 *m*)

the gap between gaps of dimension 1 exhibits proof of remaining bounded:

(A associated result from the 1970s states that the unique sequence comprises infinite-length arithmetic progressions—implying the presence of infinite runs of numbers whose variations are fixed.)

## The Extra Normal “Affine” Case: n ⟼ {a n + b, c n + d}

Not each rule of the shape

results in a fancy multiway graph. For instance

simply offers a pure binary tree since 2*n* simply provides a 1 firstly of the binary digit sequence of *n*, whereas provides one on the finish:

In the meantime

offers a easy grid

the place at degree *t* the numbers that seem are merely

and the sample of use of the 2 instances within the rule makes it clear why the grid construction happens.

Listed here are the behaviors of all inequivalent nontrivial guidelines of the shape

with constants as much as 3:

✕
Grid[Partition[ ParallelMap[ Function[{a, b, c, d}, Labeled[ Graph[ ResourceFunction["NestGraphTagged"][ n |-> {a n + b, c n + d}, {0}, 8], ImageSize -> {UpTo[80], UpTo[80]}], Textual content[Style[Row[{a, b, c, d}, " "], 9]]]] @@ # &, Choose[Flatten[Array[List, 4 {1, 1, 1, 1}, 0], 3], Operate[{a, b, c, d}, GCD[a, b, c, d] == 1 && a = a && a > 0 && c > 0 && ! (b == d == 0) && ! (a == 1 && b == 0)] @@ # &]], 8]] |

“Ribbons” are seen solely when . “Easy webs” are seen when . “Easy grids” are seen every time the 2 instances within the rule commute, i.e.

which happens every time

“Easy bushes” are seen every time

In different instances there appears to be irregular merging, as within the case above. And preserving solely nontrivial inequivalent instances these are the outcomes after eradicating free ends:

Notice that including one other component within the rule could make issues considerably extra sophisticated. An instance is:

After 8 steps this offers

or in one other rendering:

After just a few extra steps, with “free ends” eliminated, one will get the still-rather-unilluminating outcome (although one that we are going to talk about additional within the subsequent part):

## The Phenomenon of Confluence

Will each branching of paths within the multiway graph finally merge once more? In the event that they do, then the system is confluent (which on this case is equal to saying that it’s causal invariant—an essential property in our Physics Project).

It seems that every one guidelines of the next kinds are confluent:

However amongst guidelines of the shape

confluence depends upon the values of *a*, *b*, *c* and *d*. When multiway graphs are “easy webs” or “easy grids” there’s apparent confluence. And when the graphs are easy bushes, there’s clearly not confluence.

However what a couple of case just like the rule we mentioned above:

We plotted above the “positions” of mergers that happen. However are there “sufficient” mergers to “rejoin” all branchings?

Listed here are the primary few branchings that happen:

For the pair 3, 4 one can attain a “merged” finish state on the next paths:

that are embedded in the entire multiway graph (with out free ends) as:

For the pair 9, 13 each finally attain 177151, however 9 takes 13 steps to take action:

Right here’s a abstract of what we find out about what occurs with the primary few branchings:

So what concerning the complete variety of branchings and mergings? That is what occurs for the primary a number of steps:

The variety of branchings at step *t* approximates

whereas the variety of mergings appears to develop systematically extra slowly, maybe like 1.:

And based mostly on this it appears believable that the system is just not ultimately confluent. However how may we present this? And what’s the easiest way to determine if any explicit department pair (say 21, 31) will ever merge?

One technique to search for mergings is simply to evolve the multiway graph from every member of the pair, and test in the event that they overlap. However as we will see even for the pair {3, 4} this successfully includes “treeing out” an exponential variety of instances:

Is there a method to do that extra effectively, or in impact to prune the bushes? A notable characteristic of the unique rule is that the numbers it generates at all times enhance at every step. So one factor to do is simply to discard all components at a specific step in a single graph that can’t attain the “minimal frontier” within the different graph. However by itself, this results in solely very minor discount within the dimension of graph that must be thought of.

To search out what’s probably a way more efficient “optimization” let’s take a look at some examples of mergings:

It’s clear that the ultimate step has to consist of 1 utility of and considered one of (i.e. one purple edge and one blue edge). However these examples counsel that there are additionally additional regularities.

On the merging level it have to be true that

for some integers *u* and *v*. However for this to be true, the merged worth (i.e. or ) should for instance be equal to 1 mod 2, 3 and 6.

Utilizing the construction one degree again we even have:

or

implying that the merged worth have to be 3 mod 4, 7 mod 12, 13 mod 18 and 36 mod 31. Further constraints from going even additional again indicate ultimately that the merged worth will need to have the next sample of residues:

However now let’s think about the entire system modulo *okay*. Then there are simply *okay* doable values, and the multiway graph have to be finite. For instance, for we get:

Dropping the “transient components” leaves simply:

These graphs may be regarded as reductions of the multiway graph (and, conversely, the multiway graph is a protecting of them). The graphs can be regarded as finite automata that define regular languages whose components are the “2” and “3” transformations that seem on the perimeters. Any sequence of “2” and “3” transformations that may happen within the multiway graph should then correspond to a valid word in this regular language. However what we’ve seen is that for sure values of *okay,* mergers within the multiway graph at all times happen at explicit (“acceptor”) states within the finite automata.

Within the case , each merger happens on the 7 state. However by tracing doable paths within the finite automaton we now can learn off what sequences of transformations can result in a merger:

And what’s notable is that solely a sure fraction of all doable sequences of size *m* can happen; asymptotically, about 28%.

Probably the most stringent analogous constraints come from the graph:

And we see that even for sequences of size 3 fewer are allowed than from the graph:

Asymptotically the variety of allowed sequences is about 3% of the doable. And so the conclusion is that if one needs to seek out mergings within the multiway graph it’s not essential to tree out all doable sequences of transformations; one solely wants at most the 30× smaller variety of sequences “accepted by the mod-144 finite automaton”. It’s doable to perform a little higher than this, by wanting not simply at sequences allowed by the finite automaton for a specific *okay*, however at finite automata for a group of values of *okay* (say as within the desk above).

However whereas these methods ship vital sensible speedups they don’t appear to considerably alter the asymptotic assets wanted. So what is going to it take to find out whether or not the pair {21, 31} ever merges?

I don’t know. And for instance I don’t know any technique to discover an higher sure on the variety of steps after which we’d be capable to say “if it hasn’t merged but, it by no means will”. I’m certain that if we take a look at totally different department pairs, there can be tips for explicit instances. However I think that the final drawback of figuring out merging will present computational irreducibility, and that for instance there can be no basically higher technique to decide whether or not a specific department pair has merged after *t* steps than by primarily enumerating each doable evolution for that variety of steps.

However if so, it implies that the final infinite-time query of whether or not a department pair will merge is undecidable—and may by no means be assured to be answerable with a bounded quantity of computational effort. It’s a decrease bar to ask whether or not the query may be answered utilizing a finite proof in, say, Peano arithmetic. And I feel it’s very doubtless that the general query of whether or not all department pairs merge—in order that the system is confluent—is an announcement that may by no means, for instance, be established purely inside Peano arithmetic. There are fairly just a few different candidates for the “easiest ‘numerical’ assertion unbiased of Peano arithmetic”. But it surely appears not less than conceivable that this one could be extra accessible to proof than most.

It’s price mentioning, by the best way, that (as we’ve seen extensively within the Physics Undertaking) the presence of confluence doesn’t indicate {that a} multiway system should present easy general habits. Take into account for instance the rule (additionally mentioned on the finish of the earlier part):

Operating for just a few extra steps, eradicating free ends and rendering in 3D offers:

However regardless of this complexity, this can be a confluent rule. It’s already a sign of this that mergings just about “sustain” with branchings on this multiway system:

The primary few branchings (now all 3-way) are:

All of the pairs right here merge (usually considerably degenerately) in just some steps. Listed here are examples of how they work:

## Branchial Area and Numerical Worth Area

Take into account the primary few steps of the rule

At every “layer” we will type a branchial graph by becoming a member of nodes which have widespread ancestors on the step earlier than:

Persevering with for just a few extra steps we get:

We are able to think about (as we do in our Physics Undertaking) that in an acceptable (if reasonably refined) restrict such branchial graphs may be regarded as defining a “branchial area” through which every node has a particular place. (One in all many subtleties is that the actual branchial graphs we present listed here are particular to the actual “layering” of the multiway graph that we’ve used; different foliations would give totally different outcomes.)

However whereas in our Physics Undertaking and plenty of different functions of the multicomputational paradigm the one actual technique to outline “positions” for nodes within the multiway graph is thru one thing like branchial area, there’s a way more direct strategy that may be taken in multiway programs based mostly on numbers—as a result of each node is labeled by a quantity which one can think about immediately utilizing as a coordinate.

For example, let’s take the multiway graph above, and make the horizontal place of every node be decided by its worth:

Or, higher, by the log of its worth:

Persevering with for extra steps, we get:

Now, for instance, we will ask—given the actual selection of layers we’ve made right here—what the distribution of (logarithmic) values reached on successive layers can be, and one finds that the outcomes converge fairly shortly:

(By the best way, in these outcomes we’ve not included “path weights”, which decide what number of totally different paths lead from the preliminary quantity to a specific outcome. Within the instance proven, together with path weights doesn’t make a distinction to the type of the ultimate outcome.)

So what’s the correspondence between the structure of nodes in “branchial area” and in “numerical worth area”? Right here’s what occurs if we lay out a branchial graph utilizing (logarithmic) numerical worth as *x* coordinate:

Maybe extra helpful is to plot branchial distance versus (logarithmic) numerical distance for each pair of linked nodes at a specific layer:

And not less than on this case, there’s maybe a slight correlation to be seen.

## Destructive Numbers

The principles we’ve thought of to this point all contain solely non-negative numbers. What occurs if we embrace damaging numbers? Usually the outcomes are similar to these with non-negative numbers. For instance:

simply offers

in which there’s successfully each a “constructive” and “damaging” “net”.

A rule like

seems to yield primarily solely constructive numbers, yielding after eradicating free ends

offers a extra balanced assortment of constructive and damaging numbers (with constructive numbers indicated by darkish nodes), however the closing graph continues to be fairly comparable:

Up to now we’ve thought of solely guidelines based mostly on unusual arithmetic capabilities. As a primary instance of going past that, think about the rule:

Operating this for 50 steps we get:

A notable characteristic right here is that just one “contemporary” node is added at every step—and the entire thing grows like a Fermat spiral. After 250 steps the multiway graph has the shape

which we will readily see is basically a “binary tree superimposed on a spiral”.

Dividing by 3 as a substitute of two makes it a ternary tree:

Utilizing `Round` as a substitute of `Floor` offers a blended binary and ternary tree:

What about guidelines of the shape:

Listed here are the outcomes for just a few values of *a*:

Persevering with

for extra steps we get:

has far fewer “free ends”:

What are the “grid patches”? Choosing out among the patches we will see they’re locations the place a quantity that may be “halved lots” seems—and similar to in our pure multiplication guidelines above, and three*n* signify commuting operations that type a grid:

## Conditional Division, Inverse Iterations and the 3n+1 Downside

Together with `Floor`[] is a bit like having totally different capabilities for even and odd *n*. What occurs if we do that extra explicitly? Take into account for instance

The result’s primarily equivalent to the `Floor` case:

Listed here are a few different instances, not less than qualitatively just like what we’ve seen earlier than:

However now think about as we did firstly:

What’s the inverse of this? One can consider it as being

or

which supplies for instance

or persevering with for longer:

How about

Now the “inverse” is:

However on this case since most numbers will not be reached within the authentic iteration, most “don’t have inverses”. Nonetheless, choosing an preliminary quantity like 4495, which occurs to be a merge level, yields:

Notice that this “inverse iteration” at all times monotonically decreases in the direction of 0—reaching it in at most steps.

However now we will examine with the well-known *3n*+*1* problem, outlined by the “singleway” iteration:

And whereas on this case the intermediate numbers generally enhance, all recognized preliminary situations finally evolve to a easy cycle:

However now we will “invert” the issue, by considering the rule:

equal to

which supplies after 10 steps:

Persevering with this to 25 steps one will get:

Eradicating free ends this then turns into:

or after extra steps, and rendered in 3D:

The *3n*+*1* drawback now asks whether or not because the multiway graph is constructed, it’ll finally embrace each quantity. However from a multicomputational viewpoint there are new inquiries to ask—like whether or not the “inverse-*3n*+*1*-problem” multiway system is confluent.

The primary few branchings within the multiway graph on this case are

and all of those re-merge after at most 13 steps. The full variety of branchings and mergings on successive steps is given by:

Together with extra steps one will get

which suggests that there’s certainly confluence on this case—although, like for the issue of termination within the authentic *3n*+*1* drawback, it might be extraordinarily troublesome to find out this for certain.

## Different Sorts of Guidelines

All the principles we’ve used to this point are—as much as conditionals—basically “linear”. However we will additionally think about “polynomial” guidelines. With pure powers, as in

the multiway graph is simply the one related to the addition of exponents:

In a case like

the graph is a pure tree

whereas in a case like

there’s “early merging”, adopted by a pure tree:

There are additionally instances like

which result in “continued merging”

however when free ends are eliminated, they’re revealed to behave in reasonably easy methods:

In a case like

nonetheless, there’s not less than barely extra sophisticated merging (proven right here after eradicating free ends):

If we embrace damaging numbers we discover instances like:

However in different “polynomial” instances one tends to get solely bushes; a merging corresponds to an answer to a high-degree Diophantine equation, and issues just like the ABC conjecture are likely to counsel that only a few of those exist.

Returning to the “linear” case, we will think about—as we did above—multiway graphs mod *okay*. Such graphs at all times have simply *okay* nodes. And in a case like

with graph

they’ve a easy interpretation—as “remainder graphs” which one can use to compute a given enter quantity *n* mod *okay*. Take into account for instance the quantity 867, with digits 8, 6 and seven. Begin on the 0 node. Comply with 8 purple arrows, adopted by a blue one, thus reaching node 3. Then comply with 6 purple arrows, adopted by blue. Then 7 purple arrows, adopted by blue. The node that one finally ends up on by this process is precisely the rest. And on this case it’s node 6, indicating that `Mod`[867, 7] is 6.

Not too surprisingly, there’s a particular construction to such the rest graphs. Right here is the sequence of “binary the rest graphs” generated from the rule

for successive values of *okay*:

Persevering with a number-theoretical theme, we might word that the acquainted “divisor graph” for a quantity may be thought of as a multiway graph generated by the rule:

Right here’s an instance for 100:

Transitive discount offers a graph which on this case is basically a grid:

Different preliminary numbers can provide extra sophisticated graphs

however on the whole the transitive discount is basically a grid graph of dimension `PrimeNu`:

As a substitute for divisors, we will look, for instance, at a rule which transforms any quantity to the listing of numbers comparatively prime to it:

The transitive discount of that is at all times trivial, nonetheless:

One common technique to “probe” any perform is to take a look at a multiway graph generated by the rule:

Right here, for instance, is the outcome for

beginning with

:

As soon as once more, the transitive discount may be very easy:

As one other instance, we will take a look at:

the place every “efflorescence” corresponds to a major hole:

As a closing instance we will think about the digit-reversal function:

## Non-Integer Values

In virtually the whole lot we’ve mentioned to this point, we’ve been contemplating solely integer values, each in our guidelines and our preliminary situations. So what occurs if we begin a rule like

with a non-integer worth? Slightly than taking a selected preliminary worth, we will simply use a symbolic worth *x*—and it then seems that the multiway graph is similar whatever the worth of *x*, integer or non-integer:

What if the rule comprises non-integer values? In a case like

the essential properties of addition be sure that the multiway graph will at all times have the identical grid construction, no matter *a*, *b* and the preliminary worth *x*:

However in a case like

issues are extra sophisticated. For arbitrary symbolic *a*, *b* and preliminary *x*, there are not any relations that apply, and so the multiway graph is a pure tree:

For a selected worth of *b*, nonetheless, there are already relations, and a extra sophisticated construction develops:

Persevering with for extra steps and eradicating free ends we get

which is to be in comparison with the outcome from above for , :

What occurs if we select a non-integer worth of *b*, say:

We instantly see that there are “particular relations” related to and its powers:

Persevering with for longer we get the considerably advanced construction:

or in a unique rendering with free ends eliminated:

This construction may be very depending on the algebraic properties of . For a transcendental quantity like π there are not any “particular relations”, and the multiway graph can be a tree. For we get

and for :

## Complicated Numbers

There are a lot of doable generalizations to contemplate. A right away one is to advanced integers.

For actual numbers at all times generates a grid. However for instance

as a substitute generates

Persevering with for longer, the graph turns into:

One characteristic of getting values which can be advanced numbers is that these values themselves can be utilized to outline coordinates to put out the nodes of the multiway graph within the aircraft—giving on this case:

or after extra steps:

Equally

offers

The non-branching rule

yields

whereas

offers

If we mix multiplication with addition, we get totally different kinds—and we will make some fascinating mathematical connections. Take into account guidelines of the shape

the place *c* is a few advanced quantity. I thought of such guidelines in *A New Kind of Science* as a practical model of plant growth (although already then I recognized their connection to multiway systems). If we take a look at the case

the multiway graph is structurally only a tree:

But when we plot nodes on the positions within the advanced aircraft equivalent to their values we get:

Persevering with this, and deemphasizing the “multiway edges” we see a characteristic “fractal-like” pattern:

Notice that that is in some sense twin to the standard “line segment iteration” nested construction:

Including a 3rd “actual” department

we get

And with

the outcome builds as much as a typical Sierpinski pattern:

These footage counsel that not less than within the restrict of an infinite variety of steps there can be all kinds of merging between branches. And certainly it’s pretty easy to prove this. However what about after, say, *t *steps?

The outcome from every department for the rule

is a polynomial resembling

or

So now the query of merging turns into a query of discovering options to equations which equate the polynomials related to totally different doable branches. The only nontrivial case equates department {1, 1} with department {2, 2}, yielding the equation:

with resolution

We are able to see this merging in motion with the rule:

The core of what it generates is the repetitive construction:

A number of further outcomes are (the place the decimals are algebraic numbers of diploma 6, and *a* is an actual quantity):

In a case like

there’s an “early merger”

however then the system simply generates a tree:

The household of guidelines of the shape

exhibits extra elaborate habits. For we get:

Persevering with for extra steps this turns into:

For we get as a substitute:

If we take a look at the precise distribution of values obtained by such guidelines we discover for instance:

If we transcend multiway programs with pure “1 + *c* *n*” guidelines we quickly get outcomes similar to ones we’ve seen in earlier sections. For instance

offers multiway graph (after eradicating free ends)

Inserting nodes based on their numerical values this then has the shape:

## Collections of Numbers, and Causal Graphs

In finding out multiway programs based mostly on advanced numbers we’re successfully contemplating a particular case of multiway programs based mostly on collections of numbers. If the complex-number guidelines are linear, then what we’ve are iterated affine maps—that type the premise for what I’ve known as geometric substitution systems.

As a barely extra common case we will think about multiway programs through which we take pairs of numbers *v* and apply the rule

the place now *a* and *b* are matrices. If each matrices are the shape then that is equal to the case of advanced numbers. However we will additionally for instance think about a rule like

which yields

or after extra steps and in a unique rendering:

Laying this out in 2D utilizing the precise pairs of numbers as coordinates, this turns into:

Listed here are samples of typical habits with 0, 1 matrices:

Past pure matrix multiplication, we will additionally think about a rule that provides fixed vectors, as in:

We are able to additionally assume in a extra “elementwise” method, establishing for instance easy guidelines resembling

This generates the multiway graph:

Persevering with for longer and eradicating free ends yields:

✕
ResourceFunction["GraphRemoveLooseEnds"][ ResourceFunction["NestGraphTagged"][ v |-> {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 12], All] |

Utilizing values as coordinates then offers:

✕
{With[{g = ResourceFunction["NestGraphTagged"][ v |-> {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 4, "StateLabeling" -> True, "FormattingFunction" -> (Fashion[Row[Riffle[#, ","]], Black] &)]}, Graph[g, VertexCoordinates -> (# -> # & /@ VertexList[g])]], With[{g = ResourceFunction["NestGraphTagged"][ v |-> {v + {2, 1}, {1, 0} + Reverse[v]}, {{1, 1}}, 8, "FormattingFunction" -> (Fashion[Row[Riffle[#, ","]], Black] &)]}, Graph[g, VertexCoordinates -> (# -> # & /@ VertexList[g])]]} |

In our Physics Undertaking and different applications of multicomputation, we regularly talk about causal graphs, that monitor the causal relationships between updating occasions. So why is it that these haven’t come up in our dialogue of multiway programs based mostly on numbers? The essential purpose is that when our states are particular person numbers, there’s no purpose to individually monitor updating occasions and transformations of states as a result of these are precisely the identical—as a result of each time a state (i.e. a quantity) is remodeled the quantity as a complete is “consumed” and new numbers are produced. Or, in different phrases, the stream of “knowledge” is similar because the stream of “causal data”—in order that if we did file occasions, there’d simply be one on every fringe of the multiway graph.

However the story is totally different as quickly as our states don’t simply include particular person “atomic” issues, like single numbers. As a result of then an updating occasion can have an effect on simply a part of a state—and asking what causal relationships there could also be between occasions turns into one thing separate from asking concerning the transformation of entire states.

With a rule of the shape, say,

issues are nonetheless pretty trivial. Sure, there are separate “*x*” and “*y*” occasions. However they don’t combine, so we’ll simply get two unbiased causal graphs. Issues may be much less trivial in a case just like the one above, of the shape:

However now there’s a totally different drawback. Let’s say that the rule transforms {*x*, *y*} to {*y *+ 1, *x* + 1}. How ought to we decompose that into “elementary occasions”? Let’s imagine there’s one occasion that swaps *x* and *y*, and others that add 1. Or one thing totally different. It’s arduous to know.

So why haven’t we encountered this type of drawback in different multicomputational programs, say in hypergraph rewriting programs or string substitution programs? The purpose is that in these programs the underlying components at all times have a sure distinctive id, which permits their “stream” to be traced. In our Physics Undertaking, for instance, every hypergraph updating occasion that happens impacts sure explicit “atoms of area” (that we will consider as being labeled by distinctive identifiers)—and so we will readily hint how the consequences of various occasions are associated. Equally, in a string substitution system, we will hint which characters at which positions within the string had been affected by a given occasion, and we will then hint which new characters at which new positions these have an effect on.

However in a system based mostly on numbers this tracing of “distinctive components” doesn’t actually apply. We’d consider 3 as being . However there’s nothing that uniquely tags these 1s, and permits us to hint how they have an effect on 1s that may make up different numbers. In a way, the entire level of numbers is to summary away from the labeling of particular person objects—and simply ask the mixture query of “what number of” there are. So in impact the “packaging” of knowledge into numbers may be regarded as “washing out” causal relationships.

Once we give a rule based mostly on numbers what it primarily does is to specify transformations for values. But it surely’s completely doable so as to add an ancillary “causal rule”, that, for instance, can outline which components in an “enter” listing of numbers must be regarded as being “used because the inputs” to supply explicit numbers in an output listing of numbers.

There’s one other subtlety right here, although. The purpose of a multiway graph is to signify all doable totally different histories for a system, equivalent to all doable sequences of transformations for states. A selected historical past corresponds to a specific path within the multiway graph. And if—as in a multiway system based mostly on single numbers—every step on this path is related to a single, particular occasion, then the causal graph related to a specific historical past will at all times be trivial.

However in one thing like a hypergraph- or string-based system there’s normally a nontrivial causal graph even for a single path of historical past. And the reason being that every transformation between states can contain a number of occasions—appearing on totally different components of the state—and there may be nontrivial causal relationships between these occasions “mediated” by shared components within the state.

One can consider the ensuing causal graph as representing causal relationships in “spacetime”. Successive occasions outline the passage of time. And the structure of various components in every state may be regarded as defining one thing like area. However in a multiway system based mostly on single numbers, there isn’t a pure notion of area related to every state, as a result of the states are simply single numbers which “don’t have sufficient construction” to correspond to one thing like area.

If we’re coping with collections of numbers, there’s extra risk of “having one thing like area”. But it surely’s best to think about this when one’s coping with very massive collections of numbers, and when the “places” of the numbers are extra essential than their values—at which level the truth that they’re numbers (reasonably than, say, characters in a string) doesn’t make a lot distinction.

However in a multiway system one’s coping with a number of paths of historical past, not only one. And one can then begin asking about causal relationships not simply inside a single path of historical past, however throughout totally different paths: a multiway causal graph. And that’s the sort of causal graph we’ll readily assemble for a multiway system based mostly on numbers. For a system based mostly on strings or hypergraphs there’s a sure wastefulness to beginning with a normal multiway graph of transformations between states. As a result of if one appears in any respect doable states, there’s sometimes lots of repetition between the “context” of various updating occasions.

And so an alternate strategy is to look simply because the “tokens” which can be concerned in every occasion: hyperedges in a hypergraph, or runs of characters in a string. So how does it work for a multiway system based mostly on numbers? For this we’ve to once more take into consideration how our states are decomposed for functions of occasions, or, in different phrases, what the “tokens” in them are. And for multiway programs based mostly on single numbers, the pure factor is simply to contemplate every quantity as a token.

For collections of numbers, it’s much less apparent how issues ought to work. And one risk is to deal with every quantity within the assortment as a separate token, and maybe to disregard any ordering or placement within the assortment. We may then find yourself with a “multi-token” rule like

whose habits we will signify with a token-event graph:

However given this, there’s then the problem of deciding how collections of tokens must be regarded as aggregated into states. And on the whole multi-token numerical multiway programs signify a complete separate area of exploration from what we’ve thought of right here.

A fundamental level, nonetheless, is that whereas our investigations of issues like hypergraph and string programs have normally had a considerable “spatial element”, our investigation of multiway programs based mostly on numbers tends to be “extra branchial”, and really a lot centered across the relationships between totally different branches of historical past. This doesn’t imply that there’s nothing “geometrical” about what’s going on. And actually we absolutely count on that in an acceptable restrict branchial area will certainly have a geometrical construction—and we’ve even seen examples of this right here. It’s simply that that geometrical construction is—within the language of physics—concerning the area of quantum states, not about bodily area. So which means our instinct about unusual bodily area gained’t essentially apply. However the essential level is that by finding out multiway programs based mostly on numbers we will now hope to sharpen our understanding and instinct about issues like quantum mechanics.

## A lot Extra to Discover…

The essential setup for multiway programs based mostly on numbers may be very easy. However what we’ve seen right here is that—just like for so many other kinds of systems in the computational universe—the habits of multiway programs based mostly on numbers may be removed from easy.

In some ways, what’s right here simply scratches the floor of multiway programs based mostly on numbers. There’s way more to discover, in many alternative instructions. There are a lot of further connections to conventional arithmetic (and notably quantity idea) to be made. There are additionally questions concerning the geometrical buildings that may be generated, and their mathematical characterization.

Within the general study of multicomputational systems, branchial—and causal—graphs are essential. However right here we’ve barely begun to contemplate them. A very essential subject that we haven’t addressed in any respect is that of alternative possible foliations. Usually it has been troublesome to characterize these. But it surely appears doable that in multiway programs based mostly on numbers these could also be amenable to investigation with some sort of mathematical methods. As well as, for issues like our Physics Undertaking questions concerning the coordinatization of branchial area are of nice significance—and the “pure coordinatizability” of numbers makes multiway programs based mostly on numbers probably a sexy place to review these sorts of questions.

Right here we’ve thought of solely unusual multiway programs, through which the principles at all times rework one object into a number of. It’s additionally completely doable to review more general multicomputational systems through which the principles can “eat” a number of objects—and that is significantly easy to arrange within the case of numbers.

Right here we’ve largely checked out multiway programs whose states are particular person integers. However we will think about other kinds of numbers and collections of numbers. We are able to additionally think about generalizing to different kinds of mathematical objects. These could possibly be algebraic constructs (such a polynomials) based mostly on unusual actual or advanced numbers. However they might additionally, for instance, be objects from universal algebra. The essential setup for multiway programs—involving repeatedly making use of capabilities—may be regarded as equal to repeatedly multiplying by components (say, turbines) of a semigroup. With none relations between these components, the multiway graphs we’ll get will at all times be bushes. But when we add relations issues may be extra sophisticated.

Multiway programs based mostly on semigroups are in a way “decrease degree” than ones based mostly on numbers. In one thing like arithmetic, one already has fast information of operations and equivalences between objects. However in a semigroup, these all need to be constructed up. After all, if one goes past integers, equivalences may be difficult to determine even between numbers (say totally different representations of radicals or, worse, transcendental numbers).

Of their fundamental building, multiway programs are basically discrete—involving as they do discrete states, discrete branches, and discrete notions like merging. However in our Physics Undertaking and different functions of the multicomputational paradigm it’s usually of curiosity to consider “continuum limits” of multiway programs. And on condition that actual numbers present the quintessential instance of a continuum one may suppose that by one way or the other multiway programs based mostly on actual numbers one may perceive their continuum restrict.

But it surely’s not so easy. Sure, one can think about permitting a complete “actual parameter’s price” of outputs from the multiway rule. However the subject is the best way to “knit these collectively” from one step to the following. The state of affairs is considerably just like what occurs when one appears at ensembles of random walks, or stochastic partial differential equations. However with multiway programs issues are each cleaner and extra common. The closest analogy might be to path integrals of the type thought of in quantum mechanics. And in a way this isn’t stunning, as a result of it’s exactly the looks of multiway programs in our Physics Undertaking that appears to result in quantum mechanics—and in a “continuum restrict” to the trail integral there.

It’s not clear simply how multiway programs are finest generalized to the continuum case. However multiway programs based mostly on numbers appear to offer a probably promising bridge to present mathematical investigations of the continuum—and I feel have a very good likelihood of showing some elegant and highly effective arithmetic.

I first looked at multiway systems based on numbers again within the early Nineties, and I at all times meant to come back again and take a look at them additional. However what we’ve discovered right here is that they’re richer and extra fascinating than I ever imagined. And significantly from what we’ve now seen I count on them to have a really brilliant future, and for all kinds of essential science and arithmetic to hook up with them, and stream from them.