Base-2: A Space to Explore Math

Wildberger: Exceptional Structures in Math and Physics -- Graphs

Here we explore the series “Exceptional structures in mathematics and physics from dynamics on graphs” by Norman Wildberger. This video series has not officially started but the general idea is introduced here:

2 Likes

Another amazing thing from Norman …

I started to research the roots of the network given by Norman at the end of his video. So I made a small python program (see at the end of my post) which lists the new roots for each generation.
The first generation is (1,0,0,0), (0,1,0,0), (0,0,1,0) and (0,0,0,1).
The second generation contains 4 new guys : (1, 0, 1, 0), (1, 0, 0, 1), (0, 1, 1, 0), (0, 0, 1, 1).
The third contains 5 new roots (1, 1, 1, 0), (1, 0, 1, 2), (1, 0, 2, 1), (0, 1, 1, 1), (2, 0, 1, 1).

Normally the program is ok.
Already checked with another graph presented by Normal in his video.

You can find the set of root up to generation 20 here

If you count how many new roots per level, you have OEIS A019527
More information here

####################   python mini program   ####################################
# definition of the graph
L=[]
L.append([1,2])
L.append([2,1])
L.append([2,0])
L.append([0,2])
# if you comment the two next lines, the resulting set of root is more simple (see Norman video)
L.append([0,3])
L.append([3,0])

L.append([2,3])
L.append([3,2])

# roots of the first generation
dic={}
dics={}
for tete in [(1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)]:
    dics[tete]=1
# loop from generation level N to level N+1
level=1
while level < 20:
    dic={}
    for i in dics:
        dic[i]=dics[i]
    for tete in dic:
        if dic[tete]==level:
            for i in range(len(tete)):
                a=-tete[i]
                for d,f in L:
                    if d==i:
                        a+=tete[f]
# only positive roots
                if a >=0:
                    out=list(tete)
                    out[i]=a
                    out=tuple(out)
# if not not already in the set of the root, create root level + 1
                    if out not in dics:
                        dics[out]=level+1
    level+=1
# At the end of the loop, display all generations
for i in dics:
    print(dics[i],i)

1 Like

Thanks Chris for the thread!! I am just looking the video, I "ll try to play around and understand! I would like it to connect from physics point of view! Also a comment these root system looks similar to cellular automata of Steven Wolfram. Btw in Stephen’s Wolfram physics project he has some related stuff where he starts with a string and a associated rule and in each step there are branches where sometimes I think(depending to the rule) it converges.
https://www.wolframphysics.org/technical-introduction/the-updating-process-for-string-substitution-systems/string-substitution-systems/#p-201

Hi Alain, I made a small programm in mathematica where I checked with Norman’s video it looks ok and I agree with you. So, to further check with you for Root = {1,0,0,0}
I get the following ,

Root = {1,0,0,0}

Level=2 {{1,0,1,0},{1,0,0,1}}

Level=3 {{1,1,1,0},{1,0,1,2},{1,0,2,1}}

Level=4 {{1,1,1,2},{2,0,1,2},{1,0,2,2},{2,0,2,1},{1,2,2,1}}

Level=5 {{2,1,1,2},{1,1,3,2},{2,0,3,2} ,{3,0,2,2}, {1,2,2,2}, {2,2,2,1}, {2,0,2,3}}

On my side, I obtain more roots for (1,0,0,0) than you:
Level 1 : same result
Level 2 : same result
Level 3 : your results and (0, 0, 1, 0),(0, 0, 0, 1)
Level 4 : your results and (0, 1, 1, 0),(0, 0, 1, 1)
Level 5 : your results and (0, 1, 0, 0),(0, 1, 1, 1),(2, 0, 1, 1)

If I take the the first guy on your second generation {1,0,1,0}, I obtain 4 roots in next generation
(0, 0, 1, 0), (1, 1, 1, 0), (1, 0, 0, 0), (1, 0, 1, 2)

                         1
                        /  \
If you start with   0 - 1 - 0    and you apply the transformation
 
                                0
                               /  \
for node 0 you obtain      0 - 1 - 0   witch is (0,0,1,0). 

                               1
                              /  \
for node 1 you obtain     1 - 1 - 0   witch is (1,1,1,0). 

                                 1
                                /  \
for node 2 you obtain      0 - 0 - 0   witch is (1,0,0,0). 

                                  1
                                /  \
for node 3 you obtain      0 - 1 - 2   witch is (1,0,1,2).

So, something is wrong with your program

I think we get the same but I wrote what you keep at each level , not all the possible combinations .
Expanding Level 3 for the root= {1,0,1,0} I get :

node 0 = {0,0,1,0}

node 1 = {1,1,1,0}

node 2 = {1,0,0,0}

node 3 = {1,0,1,2}

and for the root = {1,0,0,1}
I get :

node 0 = {0,0,0,1}

node 1 = {1,0,0,1}

node 2 = {1,0,2,1}

node 3= {1,0,0,0}

and finally if I am correct you don’t keep all the combinations# but only them with population >2 (2 is the sum of of the numbers in root {1,0,1,0} and {1,0,0,1} respectively.
So, finally Level 3 = {{1,1,1,0},{1,0,1,2},{1,0,2,1}}

Hello all,

I’ve been traveling for most of the past month and have not been able to keep up. I’m glad to be home and doing a little math. I’m wondering if anyone has been working on the challenge from the latest post by Norman – the Mutation Game.

I have nothing rigorous at this point, but from playing around have the following observations. Clearly, no cyclic graph can be finite. The “energy” of the nodes can freely flow in a cycle.

The other observation is that any graph with more than one node of degree 3 is not finite. The “energy” of the network bounces back and forth between the two nodes of degree 3 in a feedback process.

So my working conjecture is that any non-cyclic graph with at most one node of degree 3 or higher, and all other nodes of degree 2 or less, are finite.

I find that I’m actually much more intrigued by the infinite graphs and the way the integer energy flows around. Would be neat to be able to see this flow via a computer visualization.

Hope you are all well.

Hi everyone,
I have also done some experiments using SageMath and here are the results. I have mentionned only the positive roots (which are in bijection with negative roots):

Moreover I have tried to figure out a proof based on spectral properties of the graph. I am currently stuck with the ADE tilda graphs. I can prove using spectral arguments that the max eigenvalue cannot be greater than 2 which gives directly the ADE tilda graphs as only candidate (JH Smith theorem). But, I cannot yet prove that on a graph with spectral radius = 2 (max absolute values of eigenvalues) there is necessarily unbounded populations. Would be nice to have a pure spectral argument .

An interesting problem would be also to know, in case we are on ADE graphs, if we have a unique absolute maximum population or if we have many “local” max populations and then try to find the minimal length of mutations to reach a global/local maximum.

Hi Chris, there are specific acyclic graphs that they are finite and these are the so called ADE graphs.

I worked bymyself, as Norman suggested in his video, that the ADE graphs are the case (I used paper and pen)but of course to be honest I remembered some of the pictures of the ADE in the beginning of the video :slight_smile: .

Also, you can check the paper of Norman under the title “The Mutation Game, Coxeter–Dynkin Graphs, and Generalized Root Systems”

at page 18.

Of course I checkedf computationally that for some cases I get the same results.

The maxima question is interesting. Something to explore computationally. I have a crude mutation generator working in Mathematica. Thinking in terms of this question might be a good direction to explore. Thanks.

Thanks for the paper link. I’ve just been exploring the Wikis on ADE graphs, Lie algebras, Dynkin diagrams…a whole world I’ve never explored. As the good professor says…“there’s much to learn.”

1 Like

I know analytically from condensed matter physics that the eigenvalues of the A_n graph are : 2 Cos[2pi j /(n+1)] (j=1, 2, …n) while for the A_n tilda graph ( The number of vertices are n+1) the eigenvalues are: 2 Cos[2pi j /(n+1)] ( (j=1, 2, …n+1).

Comment: In condensed matter physics the above graphs play the role of the lattice that you can solve the discrete type of the Schrodinger equation. The A_n graph is a 1 -dimenionsal lattice in which the wavefunctions are standing waves as solutions ( hard wall boundary condition) while the A_n tilda graph is a chain that you have exponential waves(wavefunction) since they can “circle” around. The eigenvalues in our case play the role of the energy and define the electronic properties of the system.

Greetings All ~

Thought you might enjoy my video about NJW’s foundational exercise from Dynamics on Graphs:1

Glad to see some code nerds here! I welcome thoughts and collaborations on the project.

you can play with the Mutation Explorer yourself here:
geometor.github.io/graphs

all the code is here on GitHub:
github.com/geometor/graphs

~ φ

1 Like

Wow, great work. Time to go explore…

Thanks Chris!

Here is part two with an introduction to the code.

Quick question. I see that the round robin mode executes the mutations using the same ordering every run. Have you tried different orderings of execution and does that make any difference to the resulting patterns?

Good question - because the order definitely matters. Both the starting point of the singleton value and the order of cycling the nodes will impact the result. You can see that if you select D4 and D4b which have a different starting origin. The impact is that you may not find all the roots.

In all cases though, in Mutation Explorer, the first node in the graph definition gets the 1 and the round robin starts on the second node in the definition.

To really answer your question, I mention in the second video that I am looking to expand the list of cycle modes. So if you have any thoughts about an algorithm let me know. We can stick it in there. Someone on the RatTrig discord suggested a greedy mode. But certainly making choices based on the current values will be of interest.

I suppose that a way to test my question would be to pick a random round robin order at the start and keep that ordering through the evolution of the system. Compare and contrast across multiple runs.

Just as an aside, another idea I’ve explored a bit is to take a graph and all its possible start states and then consider which nodes lead to ONLY a positive increase in the weight of the whole graph. I then created a graph of these graphs. So it’s a complete (?) positive state evolution graph. Of the few (small!) finite graphs that I’ve considered, this leads to a very quick convergence to the maximal state of the system and what appear to be pretty interesting graphs (with a structure that appears to be connected to the Catalan numbers). But I have lots of questions, like, is this guaranteed to produce all roots? Will this ever get stuck in local maxima?

Obviously, I’m unsure if this is a useful route of exploration, but offered in case it might inspire other ideas.

EDIT: After a moment’s consideration, I think my idea above may be the “greedy mode” you mentioned.

1 Like

I am pretty new to this world. So I have been snooping around for clues.

I think there are some here:

The numbers game & weights. And as you and NJW say, ONLY fire at positive values :slight_smile:

I think I can easily run the numbers game in parallel with the mutation game.