## Generalized WolframModel

Generalized WolframModel

{{x_,y_},{x_,z_}}Module[{w},{{x,w},{y,z},{w,y}}]

{{f[x_],y_},{x_,g[z_]}}Module[{w},{{x,w},{y,z},{w,y}}]

{f[x_,y_],g[x_,z_]}Module[{w},{{x,w},{y,z},{w,y}}]

f[g[x_],{x_,y_}]:=XXXXXX

#### Control flow / data flow

Control flow / data flow

Master-slave parallel computing: tree-based causal graph

In[]:=

ResourceFunction["SubstitutionSystemCausalGraph"][{"A""AA"},"A",5]

Out[]=

In[]:=

SubstitutionSystem["A""AA","A",5]

Out[]=

{A,AA,AAAA,AAAAAAAA,AAAAAAAAAAAAAAAA,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA}

In[]:=

ResourceFunction["SubstitutionSystemCausalEvolution"][{"A""AA"},"A",5]

Out[]=

In[]:=

ResourceFunction["SubstitutionSystemCausalPlot"][ResourceFunction["SubstitutionSystemCausalEvolution"][{"A""AA"},"A",5]]

Out[]=

In[]:=

ResourceFunction["SubstitutionSystemCausalPlot"][ResourceFunction["SubstitutionSystemCausalEvolution"][{"A""AA"},"A",5,{"Random",5}]]

Out[]=

In[]:=

ResourceFunction["SubstitutionSystemCausalPlot"][ResourceFunction["SubstitutionSystemCausalEvolution"][{"A""AA"},"A",10,{"Random",1}],"CausalGraph"True]

Out[]=

In[]:=

ResourceFunction["SubstitutionSystemCausalPlot"][ResourceFunction["SubstitutionSystemCausalEvolution"][{"A""AA"},"A",5],"CausalGraph"True]

Out[]=

In[]:=

ResourceFunction["MultiwaySystem"]["A""AA","A",5,"EvolutionEventsGraph"]

Out[]=

In[]:=

ResourceFunction["GenerationalMultiwaySystem"]["A""AA","A",5,"StatesGraph"]

Out[]=

In[]:=

ResourceFunction["MultiwaySystem"]["A""AA","A",5,"EvolutionCausalGraph"]

Out[]=

## Standard Evaluation Model

Standard Evaluation Model

Tree-based model

## Hyperbolicity

Hyperbolicity

There exists a way to make a “front of time” that progresses ; no CTCs

## Minimal Distributed Computing

Minimal Distributed Computing

A set of independent evaluators: probably each running the same rules

Minimal case: CA

< Boilerplate causal graph for the CA;

Rule-dependent causal graph;

Data-dependent causal graph [e.g. hashlife] >

Rule-dependent causal graph;

Data-dependent causal graph [e.g. hashlife] >

Next case: graph CA [ fixed graph, that defines connections between processors ]

#### parallel int x, *p

x = *p;

parallel int x, *p

x = *p;

x = *p;

## Existing Distributed Computing

Existing Distributed Computing

### Tree-based data flow

Tree-based data flow

Master-slave

Recursion

#### Recursion could be parallelized

Recursion could be parallelized

Depending on f, you might or might not allow x, y, z to be run asynchronously

E.g. List: async OK; CompoundExpression; async not OK

### Array-based data flow

Array-based data flow

E.g. CA, XXXX

### Every shared variable represent state

Every shared variable represent state

Every setting of a shared variable initiates a causal edge, which terminates when the variable is used.

Each write-read pair is a causal edge

Each write-read pair is a causal edge

### Branchlike edge is a race condition

Branchlike edge is a race condition

###

## Causal Graph Implications

Causal Graph Implications

If something has to be run sequentially, the causal graph is just a timelike path graph [at least after transitive reduction]

## Tali’s Number Adding Examples

Tali’s Number Adding Examples

### Dictionary:

Dictionary:

Sharing of elements between hyperedges: message passing [ message passing: you pass a token to your communicatee: that token is an element in the hypergraph ] The x in one hyperedge is the same x as in another hyperedge

defines communication between x and z.

y here could be a message being passed, or a shared memory location

## Quantum Computing Correspondence

Quantum Computing Correspondence

Multiway correspondence

Gate operator:

Measure operator:

Measure operator:

Need to add more states in the Bloch sphere

[ A is annihilator of 0, B is the annihilator of 1 ]

## Email, Git

Email, Git

Git causal graph? Unification of branches: merge commit

[ Is merging based only on history, or is it data dependent? ]

Accidental isomorphism: like a questionable merge

[ Is merging based only on history, or is it data dependent? ]

Accidental isomorphism: like a questionable merge

Email : does not have a merge capability .... i.e. if two people reply to the same message, you get two different chains, as opposed to one message with two replies. [I.e. causal graph of email is a tree]

### Collaborative Editing, etc.

Collaborative Editing, etc.

#### [ Operational transforms ?? ]

[ Operational transforms ?? ]

https://en.wikipedia.org/wiki/Operational_transformation