
0
Here's the blog post.
WIP!
Let addR(n) = running total after the game ends if it starts with n and addL(n) = length of the string after the game ends if it starts with n.
We start with R = 0. Then, we add n to the running total. Then, as the last number in the string decreases, the number we add to the running total decreases. So we add n1 to the running total, then n2, then n3, all the way up to 0, which is when the game ends. So addR(n) = nth triangular number.
Since only 1 character is added to the string at each step, and the starting string is 1 character long, addL(n) = n+1.
Now, instead of addR(n) and addL(n), we have add saddR(n) and saddL(n).
We start with n. Then, we add n1 to the string 2 times. Then, we add n2 to the string 2 tiâ€¦
Read more > 
Some people have tried to define their own interpretations of BEAF beyond Îµ_{0}. The problem with those interpretations is that they use X arrays instead of the array of operator, which works fine for sublegion arrays, but makes BEAF much weaker starting from {n,n/2}.
Using X arrays, {n,n/2} has growth rate Ïˆ(Î©_{Ï‰}), but using the array of operator, the growth rate of {n,m/2} depends on m:
 {n,m/2} (m = n) has growth rate Ïˆ(Î©_{Ï‰}).
 {n,m/2} (m = n+1) = n&{n,m/2} (m = n), so the m turns into an X, and {n,m/2} (m = n+1) has growth rate Ïˆ(Î©_{Ï‰})+1.
 {n,m/2} (m = n+2) = n&n&{n,m/2} (m = n), so the m turns into an X_{2}, and {n,m/2} (m = n+1) has growth rate Ïˆ(Î©_{Î©}).
 {n,m/2} (m = n+3) = n&n&n&{n,m/2} (m = n), so the m turns into an X_{3}, and {n,m/2} (m = n+1) has growthâ€¦

 Empty graph = 0
 1 vertex = 1
 2 vertices = 2
 3 vertices = 3
 n vertices = n
 1 stick = Ï‰
 1 stick + vertex = Ï‰+1
 1 stick + n vertices = Ï‰+n
 2 sticks = Ï‰2
 2 sticks + vertex = Ï‰2+1
 3 sticks = Ï‰3
 n sticks = Ï‰n
 3path = Ï‰^{2}
 3path + stick = Ï‰^{2}+Ï‰
 2 3paths = Ï‰^{2}2
 3 3paths = Ï‰^{2}3
 4path = Ï‰^{3}
 2 4paths = Ï‰^{3}2
 5path = Ï‰^{4}
 (n+1)path = Ï‰^{n}
=== npaths and 2
 [WIP]

(Can someone change the name of the blog post? I made a typo)
Not Turing Machines are networks of computers.
Each computer has 3 states (the + state, the  state, and the 0 state), an infinite tape of cells (which can store any integer, which starts at 0), and a pointer. Each computer can either be active or inactive. There is also a group of computers (which can be made up of one or more computers) that are active at the start.
When a computer is active, it can be on one of it's 3 states, depending on the integer stored by the cell that the pointer is on:
 If the integer stored by the cell that the pointer is on is positive, the computer will be in the + state.
 If the integer stored by the cell that the pointer is on is negative, the computer wâ€¦
Read more > 
In Combinatorial Game Theory (CGT), we can assign values to games that satisfy the following conditions:
 The game is a 2player game (the players are called Left and Right)
 There are many possible positions, and often a particular starting position.
 There are rules that specify the moves that either player can make from it's current position to it's options.
 Left and Right alternate turns through the whole game.
 Both players know what is going on. There is no missing information.
 There are no chance moves.
 If a player is unable to move in its turn, that player loses.
 There is always a winner.
There are a lot of values that can be assigned to positions in those games, but for now, we will only need to know two values:
 A position X has value 0 if whoeâ€¦