Inside the Binary Reflected Gray Code:
Flip-Swap Languages in 2-Gray Code Order

Combinatorial generation studies the efficient generation of each instance of a combinatorial object, such as the $n!$ permutations of $\{1,2,\ldots,n\}$ or the $\frac{1}{n+1}\binom{2n}{n}$ binary trees with $n$ nodes. The research area is fundamental to computer science and it has been covered by textbooks such as Combinatorial Algorithms for Computers and Calculators by Nijenhuis and Wilf [27], Concrete Mathematics: A Foundation for Computer Science by Graham, Knuth, and Patashnik [9], and The Art of Computer Programming, Volume 4A, Combinatorial Algorithms by Knuth [12]. In fact, Knuth’s section on Generating Basic Combinatorial Patterns is over 450 pages. The subject is important to every day programmers, and Arndt’s Matters Computational: Ideas, Algorithms, Source Code is an excellent practical resource [1]. A primary consideration is listing the instances of a combinatorial object so that consecutive instances differ by a specified closeness condition. Lists of this type are called Gray codes. This terminology is due to the eponymous binary reflected Gray code (BRGC) by Frank Gray, which orders the $2^{n}$ binary strings of length $n$ so that consecutive strings differ in one bit. The BRGC was patented for a pulse code communication system in 1953 [10]. For example, the order for $n=4$ is

Variations that reverse the entire order or the individual strings are also commonly used in practice and in the literature. We note that the order in (1) is cyclic because the last and first strings also differ by the closeness condition, and this property holds for all $n$.

One challenge facing combinatorial generation is its relative surplus of breadth and lack of depth¹¹1This is not to say that combinatorial generation is always easy. For example, the ‘middle levels‘ conjecture was confirmed by Mütze [14] after 30 years and effort by hundreds of researchers.. For example, [1], [12], and [27] have separate subsections for different combinatorial objects, and the majority of the Gray codes are developed from first principles. Thus, it is important to encourage simple frameworks that can be applied to a variety of combinatorial objects. Previous work in this direction includes the following:

1. 1.

   the ECO framework developed by Bacchelli, Barcucci, Grazzini, and Pergola [2] that generates Gray codes for a variety of combinatorial objects such as Dyck words in constant amortized time per instance;

2. 2.

   the twisted lexico computation tree by Takaoka [22] that generates Gray codes for multiple combinatorial objects in constant amortized time per instance;

3. 3.

   loopless algorithms developed by Walsh [25] to generate Gray codes for multiple combinatorial objects, which extend algorithms initially given by Ehrlich in [8];

4. 4.

   greedy algorithms observed by Williams [28] that provide a uniform understanding for many previous published results;

5. 5.

   the reflectable language framework by Li and Sawada [13] for generating Gray codes of $k$-ary strings, restricted growth strings, and $k$-ary trees with $n$ nodes;

6. 6.

   the bubble language framework developed by Ruskey, Sawada and Williams [17] that provides algorithms to generate shift Gray codes for fixed-weight necklaces and Lyndon words, $k$-ary Dyck words, and representations of interval graphs;

7. 7.

   the permutation language framework developed by Hartung, Hoang, Mütze and Williams [11] that provides algorithms to generate Gray codes for a variety of combinatorial objects based on encoding them as permutations.

We focus on an approach that is arguably simpler than all of the above: Start with a known Gray code and then filter or induce the list based on a subset of interest. In other words, the subset is listed in the relative order given by a larger Gray code, and the resulting order is a sublist (Gray code) with respect to it. Historically, the first sublist Gray code appears to be the revolving door Gray code for combinations [26]. A combination is a length $n$ binary string with weight (i.e. number of ones) $k$. The Gray code is created by filtering the BRGC, as shown below for $n=4$ and $k=2$ (cf. (1))

This order is a transposition Gray code as consecutive strings differ by transposing two bits²²2When each string is viewed as the incidence vector of a $k$-subset of $\{1,2,\ldots,n\}$, then consecutive $k$-subsets change via a “revolving door” (i.e. one value enters and one value exits).. It can be generated directly (i.e. without filtering) by an efficient algorithm [26]. Transposition Gray codes are a special case of 2-Gray codes where consecutive strings differ by flipping (i.e. complementing) at most two bits. Vajnovszki [23] proved that necklaces and Lyndon words form a cyclic $2$-Gray code in BRGC order, and efficient algorithms can generate these sublist Gray codes directly [21]. Our goal is to expand upon the known languages that are 2-Gray codes in BRGC order, and which can be efficiently generated. To do this, we introduce a new class of languages.

A flip-swap language (with respect to 1) is a set ${\bf S}$ of length $n$ binary strings such that ${\bf S}\cup\{0^{n}\}$ is closed under two operations (when applicable): (1) Flip the leftmost $1$; and (2) Swap the leftmost $1$ with the bit to its right. A flip-swap language with respect to $0$ is defined similarly. Flip-swap languages encode a wide variety of combinatorial objects.

Our second result is that every flip-swap language forms a cyclic $2$-Gray code when listed in BRGC order. This generalizes the previous sublist BRGC results [21, 23].

Our third result is a generic successor rule, which efficiently computes the next string in the $2$-Gray code of a flip-swap language, so long as a fast membership test is given.

In Section 2, we formally define our version of the BRGC. In Section 3, we prove Theorem 1.1, and define the flip-swap partially ordered set. In Section 4, we give our generic successor rule and prove Theorem 1.2. In Section 5, we present a generic generation algorithm that list out each string of a flip-swap language, and we prove Theorem 1.3.

Let $\mathbf{B}(n)$ denote the set of length $n$ binary strings. Let $BRGC(n)$ denote the listing of $\mathbf{B}(n)$ in BRGC order. Let $\overline{BRGC}(n)$ denote the listing $BRGC(n)$ in reverse order. Then $BRGC(n)$ can be defined recursively as follows, where $\mathcal{L}\cdot x$ denotes the listing $\mathcal{L}$ with the character $x$ appended to the end of each string:

For example, $BRGC(2)=00,10,11,01$ and $\overline{BRGC}(2)=01,11,10,00$, thus

$BRGC(3)=00{\bf 0},10{\bf 0},11{\bf 0},01{\bf 0},01{\bf 1},11{\bf 1},10{\bf 1},00{\bf 1}$.

This definition of BRGC order is the same as the one used by Vajnovzski [23]. When the strings are read from right-to-left, we obtain the classic definition of BRGC order [10]. For flip-swap languages with respect to 0, we interchange the roles of the 0s and 1s; however, for our discussions we will focus on flip-swap languages with respect to 1. Table 1 illustrates $BRGC(4)$ and six flip-swap languages listed in Theorem 1.1.

In this section, we formalize some of the non-obvious flip-swap languages stated in Theorem 1.1. Then we prove Theorem 1.1 for a subset of the listed languages including necklaces, prefix normal words, and feasible solutions to the 0-1 knapsack problems. The remainder of the languages are proved in the Appendix.

Consider a binary string $\alpha=b_{1}b_{2}\cdots b_{n}$. The weight of $\alpha$ is the number of 1s it contains. An inversion in $\alpha$ with respect to $0^{*}1^{*}$ is an index pair $(i,j)$ such that $i<j$ and $b_{i}=1$ and $b_{j}=0$. The number of transpositions of $\alpha$ with respect to another binary string $\beta$ of length $n$ is the minimum number of adjacent transpositions required to transform $\alpha$ to $\beta$.

A necklace is the lexicographically smallest (largest) string in an equivalence class under rotation. An aperiodic necklace is a necklace that cannot be written in the form $\beta^{j}$ for some $j<n$. A Lyndon word is an aperiodic necklace when using the lexicographically smallest string as the representative. A prenecklace is a prefix of a necklace. A block with respect to $0^{*}1^{*}$ is a maximal substring of the form $0^{*}1^{*}$. A string $\alpha=b_{1}b_{2}\cdots b_{n}=B_{b}B_{b-1}\cdots B_{1}$ is a pseudo-necklace with respect to $0^{*}1^{*}$ if $B_{b}\leq B_{i}$ for all $1\leq i<b$.

A $k$-ary Dyck word is a binary string of length $n=tk$ with $t$ copies of $1$ and $t(k-1)$ copies of $0$ such that every prefix has at most $k-1$ copies of $0$ for every $1$. The set of length $n$ prefixes of $k$-ary Dyck words is called left factors of $k$-ary Dyck words.

Let $flip_{\alpha}(i)$ be the string obtained by complementing $b_{i}$. Let $swap_{\alpha}(i,j)$ be the string obtained by swapping $b_{i}$ and $b_{j}$. When the context is clear we use $flip(i)$ and $swap(i,j)$ instead of $flip_{\alpha}(i)$ and $swap_{\alpha}(i,j)$. Also, let $\ell_{0}(\alpha)$ denote the position of the leftmost $0$ of $\alpha$ or $n+1$ if no such position exists. Similarly, let $\ell_{1}(\alpha)$ denote the position of the leftmost $1$ of $\alpha$ or $n+1$ if no such position exists. We now prove that binary strings, necklaces, prefix normal words, and feasible solutions to the 0-1 knapsack problems are flip-swap languages with respect to 1.

Binary strings: Obviously the set ${\bf B}(n)$ satisfies the two closure properties of a flip-swap language and thus is a flip-swap language. In fact, the BRGC order induces a cyclic $1$-Gray code for ${\bf B}(n)$ [12, 15].

Necklaces: Let ${\bf N}(n)$ be the set of necklaces of length $n$ and $\alpha=0^{j}1b_{j+2}b_{j+3}\cdots b_{n}$ be a necklace in ${\bf N}(n)$. By the definition of necklace, it is easy to see that $flip_{\alpha}(\ell_{\alpha})=0^{j+1}b_{j+2}b_{j+3}\cdots b_{n}\in{\bf N}(n)$ and thus ${\bf N}(n)$ satisfies the flip-first property. For the swap-first operation, observe that if $\alpha\neq 0^{n-1}1$ and $b_{j+2}=1$, then the swap-first operation produces the same necklace. Otherwise if $\alpha\neq 0^{n-1}1$ and $b_{j+2}=0$, then the swap-first operation produces the string $0^{j+1}1b_{j+3}b_{j+4}\cdots b_{n}$ which is clearly a necklace. Thus, the set of necklaces is a flip-swap language.

Prefix normal words: A binary string $\alpha$ is prefix normal with respect to $0$ (also known as $0$-prefix normal word) if no substring of $\alpha$ has more $0$s than its prefix of the same length. For example, the string 001010010111011 is a $0$-prefix normal word but the string 001010010011011 is not because it has a substring of length $5$ with four $0$s while the prefix of length $5$ has only three $0$s.

Observe that the set of $0$-prefix normal words of length $n$ satisfies the two closure properties of a flip-swap language as the flip-first and swap-first operations either increases or maintain the number of $0$s in its prefix. Thus, the set of $0$-prefix normal words of length $n$ is a flip-swap language.

Feasible solutions to $0$-$1$ knapsack problems: The input to a $0$-$1$ knapsack problem is a knapsack capacity $W$, and a set of $n$ items each of which has a non-negative weight $w_{i}\geq 0$ and a value $v_{i}$. A subset of items is feasible if the total weight of the items in the subset is less than or equal to the capacity $W$. Typically, the goal of the problem is to find a feasible subset with the maximum value, or to decide if a feasible subset exists with value $\geq c$.

Given the input to a $0$-$1$ knapsack problem, we reorder the items by non-decreasing weight. That is, $w_{i}\geq w_{i+1}$ for $1\leq i\leq n-1$. Notice that the incidence vectors of feasible subsets are now a flip-swap language. More specifically, flipping any $1$ to $0$ causes the subset sum to decrease, and so does swapping any $1$ with the bit to its right. Hence, the language satisfies the flip-first and the swap-first closure properties and is a flip-swap language.

Consider any flip-swap language ${\bf S}$ that includes the string $0^{n}$. Let $\mathcal{BRGC}({\bf S})$ denote the listing of $\bf S$ in BRGC order. Given a string $\alpha\in\mathbf{S}$, we define a generic successor rule that computes the string following $\alpha$ in the cyclic listing $\mathcal{BRGC}({\bf S})$.

Let $\alpha=b_{1}b_{2}\cdots b_{n}$ be a string in ${\bf S}$. Let $t_{\alpha}$ be the leftmost position such that $flip_{\alpha}(t_{\alpha})\in{\bf S}$ when $|{\bf S}|>1$, such a $t_{\alpha}$ exists since ${\bf S}$ satisfies the flip-first property and $|{\bf S}|>1$. Recall that $\ell_{\alpha}$ is defined to be the position of the leftmost $1$ of $\alpha$ (or $|\alpha|+1$ if no such position exists). Notice that $t_{\alpha}\leq\ell_{\alpha}$ when $|{\bf S}|>1$ since ${\bf S}$ is a flip-swap language.

Let $flip2_{\alpha}(i,j)$ be the string obtained by complementing both $b_{i}$ and $b_{j}$. When the context is clear we use $flip2(i,j)$ instead of $flip2_{\alpha}(i,j)$. Also, let $w(\alpha)$ denote the number of $1$s of $\alpha$. We claim that the following function $f$ computes the next string in the cyclic ordering $\mathcal{BRGC}({\bf S})$:

Thus, successive applications of the function $f$ on a flip-swap language ${\bf S}$, starting with the string $0^{n}$, list out each string in ${\bf S}$ in BRGC order. As an illustration of the function $f$, successive applications of this rule for the set of necklaces of length $6$ starting with the necklace $000000$ produce the listing in Table 2.

We will provide a detailed proof of this theorem in the next subsection. Observe that each rule in $f$ complements at most two bits and thus successive strings in ${\bf S}$ differ by at most two bit positions. Observe that when $0^{n}$ is excluded from ${\bf S}$, then $\mathcal{BRGC}({\bf S})$ is still a $2$-Gray code (although not necessarily cyclic). This proves Theorem 1.2.

In this section we present a generic algorithm to generate $2$-Gray codes for flip-swap languages via the function $f$.

A naïve approach to implement $f$ is to find $t_{\alpha}$ by test flipping each bit in $\alpha$ to see if the result is also in the set when $w(\alpha)$ is even; or test flipping the ($\ell_{\alpha}+1$)-th bit of $\alpha$ to see if the result is also in the set when $w(\alpha)$ is odd. Since $t_{\alpha}\leq\ell_{\alpha}$, we only need to examine the length $\ell_{\alpha}-1$ prefix of $\alpha$ to find $t_{\alpha}$. Such a test can be done in $O(nm)$ time, where $O(m)$ is the time required to complete the membership test of the set under consideration. Pseudocode of the function $f$ is given in Algorithm 1.

To list out each string of a flip-swap language ${\bf S}$ in BRGC order, we can repeatedly apply the function $f$ until it reaches the starting string. We also maintain $w(\alpha)$ and $\ell_{\alpha}$ which can be easily maintained in $O(n)$ time for each string generated. We also add a condition to avoid printing the string $0^{n}$ if $0^{n}$ is not a string in ${\bf S}$. Pseudocode for this algorithm, starting with the string $0^{n}$, is given in Algorithm 2. The algorithm can easily be modified to generate the corresponding counterpart of ${\bf S}$ with respect to $0$.

A simple analysis shows that the algorithm generates ${\bf S}$ in $O(nm)$-time per string. A more thorough analysis improves this to $O(n+m)$-amortized time per string.

The membership tests in this paper can be implemented in $O(n)$ time and $O(n)$ space; see [3, 7, 20] for necklaces, Lyndon words, prenecklaces and pseudo-necklaces of length $n$. One exception is the test for prefix normal words of length $n$, which requires $O(n^{1.864})$ time and $O(n)$ space [5]. Together with the above theorem, this proves Theorem 1.3.

Visit the Combinatorial Object Server [6] for a C implmentation of our algorithms.