What is a graceful algorithm to generate this number sequence

Question

0                   0
1                   1
1 0                 2
1 0 0               4    
1 0  1              5       
1 0 0 0             8
1 0 0 1             9
1 0 1 1             11
1 0 0 0 0           16
1 0 0 0 1           17
1 0 0 1 1           19
1 0 1 0 1           21
1 0 1 1 1           23
1 0 0 0 0 0         32
1 0 0 0 0 1         33
1 0 0 0 1 1         35
1 0 0 1 0 1         37
1 0 0 1 1 1         39
1 0 1 0 0 0         40
1 0 1 1 1 0         46

So the idea of this sequence is based on patterns in the binary. Namely we don't ever repeat patterns. So if you have 1 0, you will never include 1 0 1 0 or 1 0 1 0 1 0 And you also throw out all rotations of a binary sequence within a given digit length. If you have 1 1 0 0 you will never have 1 0 0 1

What is a minimalistic algorithm for generating this sequence and does this sequence have a name? My interest in this sequence is musical as this is a concise list of rhythms in order of complexity.

Answer 1

I think the below algorithm should be workable. It doubles/triples/quadruples/quintuples/... what we've generated so far to find disallowed sequences. Then it generates all possible sequences by attaching a 0 and a 1 to every sequence found in the previous iteration and removes the disallowed sequences. Then it checks for rotations and removes those too.

First round, generate 1 and 0.

Second round, double these to 11 and 00. These are the strings that are not allowed in this round.
Find possible permutations. (1->{10,11} 0->{00,01}). Remove the disallowed ones we just figured out.
We now have 1, 0, 10, and 01. Find rotations: 10 and 01 are rotations, so remove them but leave one. Which? Let's say 01, as in the example.

Third round, we have 1, 0, 10. We're aiming for a three-digit sequence, and doubling the two-digit sequences would get us a four-digit sequence. Tripling 1 and 0 gets us 111 and 000, which we disallow.
Find possible permutations. (10->{100,101}). Nothing to remove.
We now have 1, 0, 10, 100, 101. Find rotations: no rotations.

Fourth round, we have 1, 0, 10, 100, 101. Aiming for four digits. We do doubling and quadrupling to get the disallowed four-digits sequences: 1111, 0000, 1010.
Find possible permutations. (100->{1000, 1001}, 101->{1010, 1011}). Remove disallowed 1010.
We have 1, 0, 10, 100, 101, 1000, 1001, 1011. Find rotations: no rotations.

One note about when you have to decide which rotations to keep: In the above example we had to decide between "10" and "01". Let's see how these sequences would develop:

10->100, 101
01->010, 011

100->1000, 1001
101->1010, _1011_

011->0110, _0111_
010->0100, 0101

Iterating "rotated sequences" produces rotations of what the other "rotated sequence" would have produced, so I believe it doesn't matter which rotation you keep.

---

Update: This seems to have something to do with Lyndon words (https://en.wikipedia.org/wiki/Lyndon_word). As I couldn't find a decent list of binary Lyndon words on the internet, I used the Python code I found here: https://gist.github.com/dvberkel/1950267 to generate some more.

I've modified it a bit to make it easier to use (removed one import and changed main function to immediately start generating binary Lyndon words). I've also added a small Perl script to check whether your words are Lyndon words: https://gist.github.com/qiqitori/31175ab58d099ac4ff7573f34e7344d5

Call the Python script using e.g. python lyndon_generator.py | head -n 1010
Call the Perl script using e.g. perl lyndon.pl

Here's what the Perl script outputs:

Found rotation 1 of 1 (1) at index 1
Found rotation 01 of 2 (10) at index 2
Found rotation 001 of 4 (100) at index 3
Found rotation 011 of 5 (101) at index 4
Found rotation 0001 of 8 (1000) at index 5
Found rotation 0011 of 9 (1001) at index 6
Found rotation 0111 of 11 (1011) at index 7
Found rotation 00001 of 16 (10000) at index 8
Found rotation 00011 of 17 (10001) at index 9
Found rotation 00111 of 19 (10011) at index 11
Found rotation 01011 of 21 (10101) at index 12
Found rotation 01111 of 23 (10111) at index 13
Found rotation 000001 of 32 (100000) at index 14
Found rotation 000011 of 33 (100001) at index 15
Found rotation 000111 of 35 (100011) at index 17
Found rotation 001011 of 37 (100101) at index 18
Found rotation 001111 of 39 (100111) at index 20
Found rotation 000101 of 40 (101000) at index 16
Found rotation 010111 of 46 (101110) at index 21

As we can see, index 10 and 19 are missing, but I would bet that the next two numbers in your sequence would be equivalent to index 10 and 19.

Answer 2

(This is not meant as a separate answer, but rather as a long comment on the discovery of colleague sneep.)

The sequence described in the question are indeed basically the Lyndon words, but rotated by one character: instead of 00111 you have 10011, moving the final 1 to the first position of the string, and in general Lyndon $x{\tt 1}$ appears in your list as ${\tt 1}x$. The reason is of course that in this way the string unambiguously represents a number.

Lyndon words are the strings that are smaller than all their rotations (and hence are non-periodic). Let us check that this gives the same words, in the sense that the minimal word that starts with a 1 (your definition) is the minimal (Lyndon) word that has its final 1moved to front. Using $<$ for lexicographic order, we have ${\tt 1}x<{\tt 1}y$ iff $x<y$ iff $x{\tt 1}<y{\tt 1}$, as we wanted.

Of course we use here that Lyndon words end with 1. Indeed, if a word ends with a 0 it has say $n$ leading zero's, and it is of the form ${\tt 0}^n{\tt 1} y {\tt 0}$ which is not lexicographically less than its rotation ${\tt 0}^{n+1}{\tt 1} y$.

As sneep noted your list is missing some elements like 10010 and 100110.

The online encyclopedia of integer sequences has several items related to Lyndon words, most importantly the list of Lyndon words and the number of Lyndon words of certain length.