I found an interesting family of oscillators in a Weighted Life rule. The rule is quite complex but

the oscillators are supported by the following minimal "Miniosc" rule:

NW5,NN1,NE5,EE1,SE5,SS1,SW5,WW1,ME0,HI0,RB2,RB7,RB10,RS0,RS5,RS10

and the corresponding Golly rule is:

Code: Select all

```
num_states=2
num_neighbors=8
num_nodes=31
1 0 1
1 0 0
2 0 1
1 1 0
2 1 3
3 2 4
2 3 1
3 4 6
4 5 7
2 1 1
3 6 9
4 7 10
5 8 11
6 12 12
1 1 1
2 14 1
3 15 9
3 9 9
4 16 17
4 17 17
5 18 19
6 12 20
7 13 21
5 19 19
6 20 23
7 21 24
8 22 25
6 23 23
7 24 27
8 25 28
9 26 29
```

{code]

x = 11, y = 11, rule = Miniosc

10bo$9bo$8bo$7bo$6bo$5bo$4bo$3bo$2bo$bo$o!

[/code]

This is an oscillator with the period 126. For odd n P(n) seems to be an oscillator with (n+1)/2 as the size

of its smallest phase. For most even n P(n) is a seed of some oscillator, but for example P(2) and P(6)

vanish.

The period of P(n), shortly p(n) here, behaves irregularly for odd integers. For example:

p(15) = 30, p(17) = 1022, p(19) = 126, p(21) = 4094. My problem is that the period of P(n)

may be fairly big even for comparatively small n. I just found that the half-period of P(57) is

536,870,911, and it took nearly two days for my slow code to get it. I extracted the code from

my own simulator that serves me well as a rule-explorer, but its nextGen() is based on an

old Life-program that ! wrote about 15 years ago when learning to program.

Is it hard to write a Python script for Golly to get the period of P(n)? I've coded mainly in C, Java, Qt and

Perl and written few lines in Python.

I found experimentally that for odd n, the maximum population of P(n) is (n*n + 2*n -1)/2 and that occurs

first time at generation (p(n)/2 -1)/2. So the script should do the following for odd input n:

Check that n is odd and n > 1.

Draw P(n) as the starting pattern.

Run generations until population (n*n + 2*n -1)/2 occurs and return its generation.

Since the bounding box of P(n) is the square of nxn cells (determined always by its least phase of (n+1)/2 cells,

writing fast C code to do that should also be possible, but I'm short of time at the moment.

I'm mainly interested in number-theoretic aspects of p(n).

Risto Kauppila