First, I have to say, Wolfram One desktop and Cloud platform is a fantastic place for studying all kinds of things. I have used Jupyter notebook (mostly Python) for years and didn't know but Mathematica and Wolfram Alpha only.

Wolfram One and the Fundamental Physics project is such an inspirational combination. Currently, I'm writing an essay of Theories of Everything and this is my third week of learning these things as per Stephen Wolfram's approach to the topic. Mainly I have listened to dozens of interviews, worklogs, and lecture videos related to this, but I also decided to do some experiments with the computational side to get hands really dirty.

So this post is about Wolfram model graph rule permutations. I wish to get some feedback on what have you done with this initial dilemma of finding interesting rules. Secondly, I have questions about contributing to the Wolfram Universe model project.

Double rules

Quickly it was clear that the combinatoric explosion ruined any easy way of finding interesting rules. Even a set of dual rules such as x,y | y,z | z,x permuted to hundreds of thousands of combinations, not even counting the initial rule variations that would increase rule->replace->init combinatorics to HUGE numbers.

I generated initial set of rules by this code:

permxF = Function[params,
  Permutations[
   Flatten[Sequence @@ ConstantArray[#, First[First[params]]] & /@
     Last[params]], Last[First[params]]]]
perm1F = Function[list, permxF[{{2, {2, 2}}, list}]]
perm2F = Function[list, permxF[{{3, {1, 3}}, list}]]

permutations =
 ToExpression[#] & /@ perm2F[ToString[#] & /@ perm1F[{x, y, z}]]

This is a set of initial permutations only. The next step is to do permutations of these when we get 670k start / replace rule pairs.

What are the ways of reducing the number of exciting forms? So far I have found these two techniques:

1. remap technique where permuted list variables are replaced with numbers. In the simplest case {x,y} is same as {y,z} or {z,x} that is {1,2} if they are the only vertex in the list. Basically, this is about counting different variables in the start rule / replace rule combination and doing a variable replacement. This function will reduce the number of permutations by a factor of tens. But it cannot be done to the above initial permutations but for the start/replace set.

   remapF = Function[alist, 
     Map[Function[listitem, 
       listitem /. 
        Function[aflat, AssociationThread[aflat, Range[Length[aflat]]]][
         DeleteDuplicates[Flatten[alist]]]], alist]]
   

2. comparing Wolfram model final result to a) the start rule, b) the replacement rule and c) to the result of the previous evolution of the graph and remove all duplicates. This is more complicated thus I'm not providing that part of the code in this post.

Via these methods, I got start/replace rules reduced from initial 670k to 111k to 1008, (which is quite an intriguing number itself from factors of 2, 3, and 7). Additionally, when result graphs are stored as images to the local computer, all generated images imported and grouped to clusters via FindClusters-function, and the first image from the cluster is taken, then I got a grid of 270 models for rules comprising a form: {a,b} times 1-3 -> {a,b} times 1-3, init {1} times start rule. For example, I noticed the Mandelbrot-like figure repeating a dozen times. Graphgrid image is attached at the end of the post.

I have limited both start and replace rules to the max three pairs of {a,b}. Variables are also limited to three x, y, z. The next step could be to add the fourth pair and the fourth variable. Expecting to see further problems with reducing interesting cases...

Triple rules

Needless to say, when permutations are taken from {x,y,z,t} -> {}*3 and those combined to start/replace rules, we are dealing with billions of sets.

8Gt RAM is not sufficient to operate with this in runtime memory, so I had to use file storage (SQLite) to generate rules similar to the fashion of double rules. Finally, I got a reduced set of 4k forms that might be interesting and from those worth of publishing. Before starting this study project, I was after those forms that create a grid of triangles or squares in 2D or tetrahedrons or similar in 3D. This is the initial grid where I picked up the form:

By eye, it is easy to see the third form from the upper row is interesting because it differs from all others (4k forms) that are symmetrically repeating or extending spokes rather than creating any continuous grid-like form.

Using a manual technique by tweaking initial parameters, I got this pretty cool 3D model, which is a kind of length increasing Sock model in the simplest case but Symmetric Singularity Centered Wormhole model in this case:

http://gigabrain.io/physics/index.html?rule={{{1,1,1},{2,3,2}}-%3E{{1,2,3},{1,4,1},{3,3,3}}}&init={{1,1,1},{1,1,1},{1,1,1},{1,1,1},{1,1},{1,1,1},{1,1,1},{1,1,1},{1,1},{1,1,1},{1,1,1},{1,1},{1,1,1},{1,1}}&steps=25

Phenomenal this could be only if the side of the two funnels would meet and connect each other. But anyway, quite a cool finding after a few days of work, isn't it?

Edit: I found a similar closed from both ends form from the registry: https://www.wolframphysics.org/universes/wm1167/

Simple Sock / Closed Funnel {{{1,1,1},{2,3,2}} -> {{1,2,3},{1,4,1},{3,3,3}}}: http://gigabrain.io/physics/index.html?rule={{{1,1,1},{2,3,2}}-%3E{{1,2,3},{1,4,1},{3,3,3}}}&init={{1,1,1},{1,1,1}}&steps=25

Btw, by tweaking I mean that the most promising initial values are just the repeating 1's in various sets like {{1,1,1},{1,1},{1}} or by changing one or few of the 1's to 2 like {{2,1,1},{1,1,1},{1,1,1}}. The default starting point of mine is to have a start rule structure and just change all vertex to 1. What are your experiences with this?

Other questions

As usual, in the end, I have more questions than at the start of the session. These are some, that came to my mind in the process:

• how do you permute and reduce the list of examined form efficiently? I guess downloading some database of already published and examined wolfram universes could help.

• how do you decide the initial rule? EDIT: I found, that there is a similar initial value generator in the WolframModel that I was probably using: https://github.com/maxitg/SetReplace/tree/db6f15c7b4ae1be98be5ced0c188859e2f9eef29#automatic-initial-state

• if the start rule is longer than the replace rule, for example {{x,y},{y,z}} and {{x,z}} is it always the case, that this form of rules won't give any evolving result?

• how do you represent a hypergraph replace the system by formal/axiomatic mathematic equations, is it possible? How about math representation of individual rule sets and universes? This is a vague question but I'm looking for some way of taking these ideas in math rather than by computation, if possible.

• is it possible to collide, fuse, merge different graphs to each other?

• is it possible to make nested models in graphs, would there be any meaning similar to nested? I'm getting back to lambda calculus nested forms that can be used to represent numbers like Church numerals?

• is there a way to contribute to the possibly new models repository?

• is there an ongoing project that runs models in super / cloud computers that could be cross-checked and used in personal studies?

• how to categorize Wolfram universe models by their similarity and features? Is there some convenient way of naming them? Cactus, Pillow, and such are nice mnemonics.

• I also would like to ask generally about Theories of Everything, but where should I send my questions?

In other thread, I asked about a way to see, if the final form consists of some subform (triangular lattice for example) but I couldn't find a way to do it by isomorphic functions. Basically, it is a question of how to see if SubGraphInGraphQ[subgraph, maingraph]. That is still open if the subgraph split method is the "only" way at the moment https://community.wolfram.com/groups/-/m/t/2075211?ppauth=4ZyCoAef

-Marko