Skip to content

Aether cellular automaton definition

Jump to bottom
Jaume Ribas edited this page Jan 4, 2024 · 3 revisions

Aether

Cellular automaton in which every cell in the grid has an integer value. This value is transferred between neighboring cells following a set of rules. The total value of the grid is always conserved.

Definition:

Each step, the following actions are performed for every cell:

  1. Make a list of the von Neumann neighbors whose value is less than that of the current cell. If no neighbors meet this condition, do not perform any other action.
  2. Create a temporary value for each neighbor in the list, initialized to zero.
  3. Compare the value of the current cell with the greatest value from the neighbors in the list.
  4. Subtract this value difference from the current cell's value, and divide it between all neighbors in the list and the current cell. If there is a remainder from the division, add it back to the current cell's value.
  5. Add the quotient of this division to the temporary values of each neighbor in the list.
  6. Also add the quotient to the current cell's value.
  7. Transfer to the neighbors in the list, with value equal to the greatest value in the list, their corresponding temporary values. And remove them from the list.
  8. If the list is not empty, jump back to action 3. Note that the value of the current cell may be smaller, while the values of the remaining neighbors in the list has not changed. Only their temporary values may be greater.

The values of the cells at the next step result from adding to each cell's remaining value the value transferred to them by their neighbors.

Note that the value transferred to a neighbor depends on the values of the other neighbors. For this reason, it is not enough to know the value of a cell and its von Neumann neighborhood at a given step, to know the value this cell will have at the next step.

2D Example:

Step 0

                
      101      
                 

Start off with an infinite grid padded with 0 and a value of 101 at one cell.

Perform the actions for the cell with value 101:

  1. Make a list of von Neumann neighbors with smaller value. In this example, all four neighbors have less value (0):

    Neighbor Value
    UP 0
    DOWN 0
    LEFT 0
    RIGHT 0

  2. Create temporary values:

    Neighbor Value Temporary value
    UP 0 0
    DOWN 0 0
    LEFT 0 0
    RIGHT 0 0

  3. Compare the current cell's value (101) with the greatest from the list (0):

    101 - 0 = 101

  4. Subtract the difference from the current cell's value:

    101 - 101 = 0

    Divide it between the neighbors in the list (4) and the current cell:

    101/(4 + 1) = 20

    Add the remainder (1) back to the current cell:

    0 + 101%5 = 1

  5. Add the quotient (20) to the neighbors' temporary values:

    Neighbor Value Temporary value
    UP 0 20
    DOWN 0 20
    LEFT 0 20
    RIGHT 0 20

  6. Add the quotient to the current cell's value:

    1 + 20 = 21

  7. Transfer to the neighbors with value equal to the greatest in the list (0) their corresponding temporary values:

    UP +20,
    DOWN +20,
    LEFT +20,
    RIGHT +20

    Remove them from the list:

    Neighbor Value Temporary value
  8. The list is empty.

The resulting configuration is as follows:

Step 1

         
    20    
  20 21 20  
    20    
         

Perform the actions again:

Top cell with value 20:

  1. In this case, there are only three neighbors in the list since one neighbor has a value greater than that of the current cell (DOWN: 21):

    Neighbor Value
    UP 0
    LEFT 0
    RIGHT 0

  2. Create temporary values:

    Neighbor Value Temporary value
    UP 0 0
    LEFT 0 0
    RIGHT 0 0

  3. Compare the current cell's value (20) with the greatest from the list (0):

    20 - 0 = 20

  4. Subtract the difference from the current cell's value:

    20 - 20 = 0

    Divide it between the neighbors in the list (3) and the current cell:

    20/(3 + 1) = 5

    Add the remainder (0) back to the current cell:

    0 + 20%4 = 0

  5. Add the quotient (5) to the neighbors' temporary values:

    Neighbor Value Temporary value
    UP 0 5
    LEFT 0 5
    RIGHT 0 5

  6. Add the quotient to the current cell's value:

    0 + 5 = 5

  7. Transfer to the neighbors with value equal to the greatest in the list (0) their corresponding temporary values:

    UP +5,
    LEFT +5,
    RIGHT +5

    Remove them from the list:

    Neighbor Value Temporary value
  8. The list is empty.

For all other cells with value 20 the actions will be equivalent to those above, only changing the direction of the neighbors.

Center cell with value 21:

  1. Make list of von Neumann neighbors with smaller value:

    Neighbor Value
    UP 20
    DOWN 20
    LEFT 20
    RIGHT 20

  2. Create temporary values:

    Neighbor Value Temporary value
    UP 20 0
    DOWN 20 0
    LEFT 20 0
    RIGHT 20 0

  3. Compare the current cell's value (21) with the greatest from the list (20):

    21 - 20 = 1

  4. Subtract the difference from the current cell's value:

    21 - 1 = 20

    Divide it between the neighbors in the list (4) and the current cell:

    1/(4 + 1) = 0

    Add the remainder (1) back to the current cell:

    20 + 1%5 = 21

  5. Add the quotient (0) to the neighbors' temporary values:

    Neighbor Value Temporary value
    UP 20 0
    DOWN 20 0
    LEFT 20 0
    RIGHT 20 0

  6. Add the quotient to the current cell's value:

    21 + 0 = 21

  7. Transfer to the neighbors with value equal to the greatest in the list (0) their corresponding temporary values:

    UP +0,
    DOWN +0,
    LEFT +0,
    RIGHT +0

    Remove them from the list:

    Neighbor Value Temporary value
  8. The list is empty.

In this case, the actions have no effect.

The resulting configuration is as follows:

Step 2

    5    
  10 5 10  
5 5 21 5 5
  10 5 10  
    5    

Note that the corner cells with value 10 received value 5 from two of their neighbors. These values are added up to get the resulting value.

Perform the actions again:

Top left corner with value 10:

  1. In this case, all neighbors are smaller but with two different values:

    Neighbor Value
    UP 0
    DOWN 5
    LEFT 0
    RIGHT 5

  2. Create temporary values:

    Neighbor Value Temporary value
    UP 0 0
    DOWN 5 0
    LEFT 0 0
    RIGHT 5 0

  3. Compare the current cell's value (10) with the greatest from the list (5):

    10 - 5 = 5

  4. Subtract the difference from the current cell's value:

    10 - 5 = 5

    Divide it between the neighbors in the list (4) and the current cell:

    5/(4 + 1) = 1

    Add the remainder (0) back to the current cell:

    5 + 5%5 = 5

  5. Add the quotient (1) to the neighbors' temporary values:

    Neighbor Value Temporary value
    UP 0 1
    DOWN 5 1
    LEFT 0 1
    RIGHT 5 1

  6. Add the quotient to the current cell's value:

    5 + 1 = 6

  7. Transfer to the neighbors with value equal to the greatest in the list (5) their corresponding temporary values:

    DOWN +1,
    RIGHT +1

    Remove them from the list:

    Neighbor Value Temporary value
    UP 0 1
    LEFT 0 1
  8. In this case, the list is not empty, so jump back to action 3.

  1. Compare the current cell's remaining value (6) with the greatest from the list (0):

    6 - 0 = 6

  2. Subtract the difference from the current cell's value:

    6 - 6 = 0

    Divide it between the remaining neighbors in the list (2) and the current cell:

    6/(2 + 1) = 2

    Add the remainder (0) back to the current cell:

    0 + 6%3 = 0

  3. Add the quotient (2) to the neighbors' temporary values:

    Neighbor Value Temporary value
    UP 0 3
    LEFT 0 3

  4. Add the quotient to the current cell's value:

    0 + 2 = 2

  5. Transfer to the neighbors with value equal to the greatest in the list (0) their corresponding temporary values:

    UP +3,
    LEFT +3

    Remove them from the list:

    Neighbor Value Temporary value
  6. The list is empty.

Perform the actions for all other cells to get the next step's configuration:

Step 3

      1      
    4 2 4    
  4 2 10 2 4  
1 2 10 9 10 2 1
  4 2 10 2 4  
    4 2 4    
      1      

Continue until the value is so spread out that the actions take no effect.

Step 4

                 
      1 1 1      
    2 2 4 2 2    
  1 2 6 4 6 2 1  
  1 4 4 9 4 4 1  
  1 2 6 4 6 2 1  
    2 2 4 2 2    
      1 1 1      
                 

Step 5

                 
      1 2 1      
    2 3 3 3 2    
  1 3 4 5 4 3 1  
  2 3 5 5 5 3 2  
  1 3 4 5 4 3 1  
    2 3 3 3 2    
      1 2 1      
                 

Step 6

        1        
      2 1 2      
    2 2 4 2 2    
  2 2 4 4 4 2 2  
1 1 4 4 5 4 4 1 1
  2 2 4 4 4 2 2  
    2 2 4 2 2    
      2 1 2      
        1        

Step 7

        1        
      2 2 2      
    2 2 3 2 2    
  2 2 4 4 4 2 2  
1 2 3 4 5 4 3 2 1
  2 2 4 4 4 2 2  
    2 2 3 2 2    
      2 2 2      
        1        

END

Clone this wiki locally