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

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

Tree-based model

Hyperbolicity

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

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] >
Next case: graph CA [ fixed graph, that defines connections between processors ]

parallel int x, *p
x = *p;

Existing Distributed Computing

Tree-based data flow

Master-slave
Recursion

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

E.g. CA, XXXX

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

Branchlike edge is a race condition

​

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

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

Multiway correspondence
Gate 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

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
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.

[ Operational transforms ?? ]

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