Rule-Based Generation of De Bruijn Sequences: Memory and Learning

1. Introduction

Cellular Automata (CA) are a class of dynamical systems that evolve in discrete time and space [17,18]. A CA consists of cells (or agents), each of which can adopt a state from a discrete set. The most commonly used alphabet is binary, typically denoted by $\{0,1\}$. The CA evolves by applying generating rules at each time step. These rules can be static or dynamic (i.e., they may change depending on the current state of the entire CA), and either local or global, depending on whether they involve only neighboring cells or the entire population.

From an initial configuration, the state of the CA evolves over time according to the specified rules. The update rule for each cell can depend on both the past states of the cell itself (temporal dimension) and the states of its neighboring cells (spatial dimension). Elementary one-dimensional cellular automata (1dCA) typically assume a memoryless structure with a linear topology, where each cell interacts only with its nearest neighbors [17]. More complex models incorporate memory—i.e., dependence on a set of past states—and long-range spatial influences [13,15].

Relatively less attention has been given to zero-dimensional cellular automata (0dCA), which consist of a single cell whose state is updated based solely on its own past states. Despite their apparent simplicity, 0dCA do not involve interactions between multiple cells, their time evolution yields interesting sequences of symbolic states. The rules governing such systems depend on the memory $\mu$—the number of previous states influencing the next state—and the alphabet $\left\{\alpha \right\}$, the number of possible states a cell can take. Generally, the complexity of the system increases with both $\mu$ and $\alpha$. For simplicity, we focus on binary systems, i.e., $\alpha =2$, using the symbols $\{0,1\}$.

2. 0-Dimensional CA

Symbolic sequences naturally arise in discrete dynamical systems, e.g., CA [11]. From an initial condition, the next state is computed according to a generation rule (or function) that depends on previous states. For instance, a classical non-Markovian binary time series can be defined by initial values $a_1$ and $a_2$, and a recursive rule:

$$a_{k+2}=(a_{k+1}+a_k)mod2,\mathrm{for}k=1,2,\dots$$

(1)

With initial states $a_1=0$ and $a_2=1$, the sequence continues as $a_3=1$, $a_4=0$, $a_5=1$, $a_6=1$, etc., producing the binary sequence:

$$s_1=0110110110110\dots$$

This sequence is clearly periodic with period $T_1=3$. In this case, the next digit depends on the two previous digits, implying a memory $\mu =2$.

Other examples with $\mu =2$ can be constructed using logical operators. For instance, applying the AND function with the rules:

$$11\to 1,10\to 0,01\to 0,00\to 0$$

to the initial pair $01$ produces the sequence:

$$s_2=0100000\dots$$

Similarly, applying the OR function:

$$11\to 1,10\to 1,01\to 1,00\to 0$$

to the same initial configuration $01$ results in:

$$s_3=0111111\dots$$

Both sequences converge to fixed values (0 or 1), i.e., their periods are $T_2=T_3=1$, and these fixed points are independent of the initial configuration.

In contrast, applying the XOR function:

$$11\to 0,10\to 1,01\to 1,00\to 0$$

to the initial state $a_1=0,a_2=1$ yields:

$$s_4=0110110110\dots$$

with period $T_4=3$. However, using the same rule with the initial configuration: $a_1=0,a_2=0$ results in a constant sequence $a_k=0$ for all $k>2$. These examples illustrate that the resulting behavior depends not only on the rule but also on the initial conditions.

For any finite memory $\mu <\infty$, all sequences generated in this framework are eventually periodic. That is, for any rule and initial condition, the sequence will eventually settle into a repeating pattern (also referred to as a motif or loop). The maximum possible period for a sequence with memory $\mu$ is:

$$T_{\max }=2^{\mu }$$

(2)

As $\mu$ increases, the sequences may resemble aperiodic ones, making them useful for computing pseudorandom numbers to be applied in Monte Carlo simulations, and cryptographic systems [7]. Truly aperiodic behavior can only arise when $\mu \to \infty$, or when the alphabet is infinite (e.g., using real-valued states).

To explore periodicity in 0dCA, we adopt combinatorial generating rules analogous to those used in 1dCA [17], with memory playing the role of spatial interaction. Formally, a generating rule with memory $\mu$ is a function that maps each of the $2^{\mu }$ binary sequences of length $\mu$ to a single binary output:

$$R(a_1,a_2,\dots ,a_{\mu })=a_j$$

(3)

where $a_i\in \{0,1\}$ for all i (see Figure 1). Starting from an initial configuration, the rule is applied recursively to generate the digits of the sequence as follows:

$$a_{j+1}=R(a_{j-\mu +1},a_{j-\mu +2},\dots ,a_j)$$

(4)

which eventually converges to an asymptotic pattern with period T.

For example, when $\mu =3$, there are $2^{2^3}=256$ possible rules—corresponding to Wolfram’s elementary 1dCA rules. Figure 1A shows the XOR rule for $\mu =3$, represented by the binary rule string 10010110, which corresponds to rule number 150 in Wolfram’s classification. Applying this rule to the initial configuration $010$ yields:

$$s_5=010101010\dots$$

which has period $T_5=2$.

In general, for a given $\mu$, the total number of possible generating rules is $2^{2^{\mu }}$, and the maximum number of binary sequences generated from these rules is:

$$C\left(\mu \right)=2^{2^{\mu }+\mu }$$

This number grows super-exponentially with $\mu$, making exhaustive analysis computationally infeasible for large $\mu$. For instance, when $\mu =10$, there are approximately ${10}^{308}$ rules, each of which must be applied to 1024 different initial configurations.

This raises the fundamental question: given a memory value $\mu$ and an initial configuration, is it possible to predict the asymptotic pattern and period T of the resulting sequence? While this is tractable for small $\mu$ via exhaustive enumeration, alternative methods are necessary for large $\mu$ due to the sheer size of the rule space.

It is worth noting that the 0-dimensional Cellular Automata (0dCA) with memory, as defined above, are equivalent to sequences generated by a Linear Feedback Shift Register (LFSR). This type of sequence has been extensively studied, and a vast body of literature exists on the subject [9]. In particular, significant attention has been devoted to the characterization and computation of shift register sequences with maximum period—commonly known as de Bruijn sequences [5,8,14]. As we will show in the next section, there exists a one-to-one correspondence between de Bruijn sequences and their generating rules, which we will refer to as de Bruijn rules.

3. Rules that Generate Maximum Period Sequences: de Bruijn Rules

For a given memory length $\mu$, the maximum period that a generated binary sequence can attain is $T_{\max }=2^{\mu }$. Naturally, the minimum period is 1, corresponding to sequences that converge to fixed points (e.g., either 0 or 1). For small values of $\mu$, it is feasible to generate all possible sequences and compute their corresponding periods. Figure 2 and Table 1 show, respectively, the bar chart of the observed periods and the associated frequencies for the case $\mu =4$.

Sequences with maximum period, known as de Bruijn sequences, are of particular interest. These are cyclic sequences of length $2^{\mu }$ in which every possible binary substring of length $\mu$ appears exactly once. For small values of $\mu$, it is straightforward to generate all possible de Bruijn sequences. There exists a unique de Bruijn sequence for $\mu =2$, namely 0011. For $\mu =3$, there are two such sequences: 00010111 and 00011101, that are generated by rules 45 and 75, respectively (rule 45 is graphically described in Figure 1B).

Since these sequences are cyclic, their representations are not unique; by convention, we select the lexicographically least sequence (i.e., the smallest in binary order and decimal number) as the representative of the equivalence class. Specially significative is the lexicographically least sequence for each memory $\mu$, that is referred to as the granddaddy in [12].

The number of binary de Bruijn sequences for a given $\mu$ is given by $C\left(\mu \right)=2^{2^{\mu -1}-\mu }$ [2,5]. This number grows also superexponentially with $\mu$ and reaches extremely large values even for moderate $\mu$. For example, for $\mu =10$, $C\left(10\right)\approx {10}^{151}$. Generating all de Bruijn sequences is a challenging combinatorial problem that remains unsolved in full generality, though various efficient construction algorithms have been proposed (see, for instance, [6]).

De Bruijn sequences can be generated by applying certain specific rules, independently of the initial configuration of length $\mu$. In other words, there exists a bijection between de Bruijn sequences and their corresponding rules, which we refer to as de Bruijn rules . Table 2 lists the de Bruijn rules and their de Bruijn sequences for $\mu =1,2,3$, and 4, expressed both as binary maps and in their corresponding decimal representations.

For $\mu =4$, there are $C\left(4\right)=2^{2^3-4}=16$ de Bruijn rules and their associated de Bruijn sequences. As it can be seen, the granddaddy sequence is: 0000100110101111. The corresponding granddaddy rule is 3825, with binary representation 0000111011110001. For $\mu =5$, the number of de Bruijn sequences is $C\left(5\right)=2^{2^4-5}=2048$. The granddaddy rule in this case is 00001100111111101111001100000001 (whose decimal representation is 218034945), which generates the granddaddy sequence: 00000100011001011011101010011111.

4. Characterization of de Bruijn Rules

As stated in the previous section, certain generating rules produce sequences with maximum period—we refer to them as de Bruijn sequences. Therefore, a complete characterization of such rules emerges as a fundamental goal. The following properties help identify and constrain the set of de Bruijn rules, and can be used to systematically search for them:

• Boundary Conditions: The binary representations of de Bruijn rules must start with 0 and end with 1. This condition arises from the convention in rule ordering, which arranges input strings from the highest binary value ($11\dots 11$) to the lowest ($00\dots 00$), and from the necessity to avoid fixed points (e.g., if $R(11\dots 11)=1$, the sequence remains constant). This constraint immediately reduces the number of candidate rules by a factor of 4. For example, for $\mu =4$, the number of potentially valid rules is reduced from $2^{2^4}=65536$ to 16384.
• Symmetry and Parity: The binary representations of de Bruijn rules are symmetric with respect to their midpoint, such that each half is the complement of the other. This symmetry ensures parity: the number of 0s equals the number of 1s, although the balance may be broken within each half. Under this constraint, valid de Bruijn rules correspond to multiples of certain numbers derived from sequences of Evil Odd numbers [1], multiplied by factors denoted as $\varphi \left(\mu \right)$.
  For instance, if we denote the Evil Odd Numbers, i.e., an odd number whose binary representation contains an even number of 1, for each $\mu$ as $R{\left(\mu \right)}_k$, being $k=1,2,\dots ,C\left(\mu \right)$, we get:

  $$R{\left(2\right)}_1=1\times 3=3,R{\left(3\right)}_1=3\times 15=45,R{\left(3\right)}_2=5\times 15=75$$
  The factors follow the recursive relation:

  $$\varphi (\mu +1)=\varphi \left(\mu \right)·\left(2^{2^{\mu }}+1\right)$$

  (5)
  For instance, $\varphi \left(2\right)=1$, $\varphi \left(3\right)=15$, $\varphi \left(4\right)=255$, and $\varphi \left(5\right)=65535$. Table 2 presents all de Bruijn rules for $\mu =4$ whose decimal representations are products of an Evil Odd number and the corresponding $\varphi \left(\mu \right)$. Note, however, that not all Evil Odd numbers yield valid de Bruijn rules, and the problem of determining which ones do remains open for larger values of $\mu$. For $\mu =4$, applying these conditions reduce the feasible set of de Bruijn rules to 32.
• Constrained Position Pairs: There exist pairs of positions in the binary representation of de Bruijn rules that cannot simultaneously take the same value (1 for even $\mu$-values and 0 for odd ones). This condition is applied only to the first half of the binary string for symmetry (according to the previous item) and depends on $\mu$ according to a recursive pattern. Specifically: For $\mu =2$, the constrained positions are $p_2^1=1$ and $p_2^2=2p_2^1$, and

  -

  If $\mu =2k+1$, then $p_{2k+1}^1=p_{2k}^2$ and $p_{2k+1}^2=2p_{2k+1}^1-1$.

  -

  If $\mu =4k$, then $p_{4k}^1=p_{4k-1}^2$ and $p_{4k}^2=2p_{4k}^1$,

  for $k=1,2,\dots$. This structural condition eliminates $1/4$ of the remaining candidates. For example, for $\mu =4$ these positions are $p_4^1=3$ and $p_4^2=6$. For $\mu =5$, $p_5^1=6$ and $p_5^2=11$.
  Remarkably, for $\mu =4$, the final count of feasible de Bruijn rules after applying all constraints is 24. In general, for all values of $\mu$, the feasible set exceeds the actual number of de Bruijn rules (see Table 3).
• Symmetric Rule Invariance: If a rule of the form:

  $$0a_1{a}_2\dots a_{k-1}{a}_{k}011-a_{1}1-a_2\dots 1-a_{k-1}1-a_{k}1$$

  is a de Bruijn rule, then its mirrored version:

  $$0a_k{a}_{k-1}\dots a_2{a}_{1}011-a_{k}1-a_{k-1}\dots 1-a_{2}1-a_{1}1$$

  is also a de Bruijn rule.
  This property reflects the inherent symmetry and reversibility in de Bruijn rule structure. It ensures that for each valid de Bruijn rule constructed in this way, a corresponding reverse-complement rule also exists within the de Bruijn set.

The application of the properties stated in the previous paragraphs to the entire set of generating rules significantly reduces the number of feasible rules that can yield de Bruijn sequences. Table 3 presents the total number of rules, the number of de Bruijn sequences, the number of feasible rules after applying the constraints, and the corresponding ratios.

As can be observed, the number of feasible rules that need to be checked to find de Bruijn rules is drastically smaller than the total number of rules for each $\mu$ value. For instance, when $\mu =6$, the reduction factor is approximately ${10}^{-11}$. In the same case, the ratio between the number of rules that actually yield de Bruijn sequences and the number of feasible rules is around $0.17$. For such low values of $\mu$, a brute-force approach may still be used to generate all de Bruijn sequences. However, a more efficient and structured methodology will be presented in the next section.

5. Neural Networks to Classify de Bruijn Rules

An alternative approach to identifying de Bruijn rules is to apply machine learning methods. In particular, neural networks are especially well-suited for classification tasks [4]. In this section, we present a neural network model for classifying the feasible rules into two categories: de Bruijn rules (coded by 1) and the rest (0). Although classification based on the sequence period is also possible, it would require accounting for dependence on initial conditions. The classification is performed for $\mu =5$ and $\mu =6$ (see Table 4).

We implemented a binary classification model using a feedforward neural network in R [16]. The analysis followed these main steps:

• Data loading and preprocessing: The input data consisted of a character string representing a binary sequence and a binary integer label.
• Feature extraction: Each rule was split into individual bits transforming the strings into a matrix where each column corresponds to a bit (${\mathrm{bit}}_1$ to bit${\mathrm{bit}}_{2^{\mu }}$). According to the necessary properties of de Bruijn rules (see Section 4), only the first $\mu /2$ bits were retained for further analysis. The first and the $2^{\mu -1}$ bits were also removed because they are necessarily 0.
• Dataset splitting: The data was randomly split into training (80%) and testing (20%) subsets to evaluate model performance on unseen data.
• Model specification and training: A feedforward neural network was constructed using the keras package with a TensorFlow backend [3,16].

Feedforward neural networks are highly suitable for structured, tabular data, such as the bit vectors extracted from rule representations. They can capture complex, non-linear relationships between input features without requiring explicit feature engineering. In our case, the binary inputs represent discrete features, and their interactions are not trivially captured by simpler linear models. The multi-layer architecture enables hierarchical feature learning, significantly improving classification accuracy.

For the case $\mu =5$, the neural network architecture includes:

• An input layer with 14 features (bits),
• A hidden dense layer with 32 units and ReLU activation,
• A second hidden dense layer with 16 units and ReLU activation,
• An output layer with 1 unit and sigmoid activation for binary classification.

The model was compiled using the Adam optimizer (learning rate $=0.001$), binary cross-entropy loss function, and accuracy as a performance metric. The dataset includes the complete set of 6144 feasible rules, one-third of which are de Bruijn rules (see Table 3). Training was performed over 100 epochs with a batch size of 4. Model evaluation was conducted on the test set by calculating accuracy, sensitivity, and specificity (see Table 4). Class labels were assigned using a threshold of 0.5 on the predicted probabilities. The resulting classifier achieved outstanding performance, with an accuracy exceeding 99% for $\mu =5$.

The more challenging case of $\mu =6$ involves a rule space of size on the order of ${10}^{19}$, with approximately 67 million de Bruijn rules (see Table 3). As a matter of fact, we can only use a sample of the total rule space that is randomly analyzed and classified into the two classes.

Optimal results were achieved using a slightly deeper neural network with the following architecture:

• Three hidden dense layers with 64, 64, and 8 units respectively,
• ReLU activations in all hidden layers,
• A sigmoid output unit for binary classification.

Training used a batch size of 64 and a learning rate of $0.001$. The dataset consists of a sample of $2\times {10}^6$ feasible rules, half of which are de Bruijn rules. As before, 80% of the dataset was used for training, and the remainder for testing. A threshold of 0.5 was again applied to the output probabilities to assign class labels. As shown in Table 4, this model also demonstrated excellent classification metrics.

Once the neural network model is available, any given rule can be evaluated to determine, with high probability, whether it is a de Bruijn rule. If the prediction is positive, the rule is then applied to generate the corresponding binary sequence, which must ultimately be verified to confirm that it satisfies the de Bruijn sequence properties.

6. Discussion

The successive application of updating rules to an initial configuration of $\{0,1\}$ generates a binary sequence that becomes asymptotically periodic. The size of the initial configuration depends on the memory of the rule, denoted by $\mu$, which is the number of digits required to update the next one. For large values of $\mu$, the number of possible generating rules becomes so large that an exhaustive analysis of the resulting patterns is infeasible. Particularly relevant is a specific and highly constrained subset of rules, that we named as de Bruijn rules, that generate sequences of maximum period, known as de Bruijn sequences. Although these sequences represent only a tiny fraction of the entire set of possible sequences, their sheer number for large $\mu$ remains enormous, and the complete and effective generation of all such sequences is still an open problem.

In this paper, we have presented a novel approach to compute de Bruijn sequences that combines two complementary methodologies. First, by exploiting structural properties of de Bruijn rules—i.e., those rules that generate maximum period sequences—a drastic reduction of the full set of candidate rules can be achieved. Table 3 summarizes the reduction ratios for several values of $\mu$. Second, we applied a machine learning approach to this feasible subset in order to accurately identify the de Bruijn rules. As shown in Section 5, the use of a classical neural network model for $\mu =5$, and 6 allows for nearly complete classification of de Bruijn rules in the smaller cases, and achieves over 99% and 94% accuracy for $\mu =5$ and $\mu =6$, respectively. Once the de Bruijn rules are identified, the corresponding de Bruijn sequences are straightforward to construct. This would allow to find granddaddy sequence that represents the lexicographically smallest member for each $\mu$-value.

To the best of our knowledge, this is the first attempt to generate de Bruijn sequences using a hybrid approach that integrates Machine Learning techniques within the framework of Cellular Automata for generating maximum period sequences. It is worth mentioning that existing methods based on Feedback Shift Register generation have not definitively solved the problem. Therefore, we believe that the results presented in this paper represent a significant step forward in the study and generation of this important class of sequences.