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

Abstract

We investigate binary sequences generated by non-Markovian rules with memory length $\mu$, similar to those adopted in elementary cellular automata. This generation procedure is equivalent to a shift register, and certain rules produce sequences with maximal periods, known as de Bruijn sequences. We introduce a novel methodology for generating de Bruijn sequences that combines (i) a set of derived properties that significantly reduce the space of feasible generating rules and (ii) a neural-network-based classifier that identifies which rules produce de Bruijn sequences. The experiments for some values of $\mu$ demonstrate the approach’s effectiveness and computational efficiency.

1. Introduction

Cellular automata (CA) are a class of dynamical systems that evolve in discrete time and space [1,2]. 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 [1]. More complex models incorporate memory—i.e., dependence on a set of past states—and long-range spatial influences [3,4].

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\}$, and, due to computational limitations, we restrict our study to a subset of cases with relatively low values of $\mu$ (less than 8).

2. 0-Dimensional CA

Symbolic sequences naturally arise in discrete dynamical systems, e.g., CA [5]. 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 following 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 [6]. 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 [1], 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=1,2,\dots ,\mu$ (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 =1,2,3,\dots$, the total number of possible generating rules is $C\left(\mu \right)=2^{2^{\mu }}$ (this number corresponds with the Fermat number minus 1 [7]), and the maximum number of binary sequences generated from these rules is $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 following 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 Non-Linear Feedback Shift Register (NLFSR). This type of sequence has been extensively studied, and a vast body of literature exists on the subject [8,9,10,11]. 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 [12,13,14,15]. 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. For $\mu =4$,

Table 1. Number of rules that generates sequences with each of the possible periods (columns) that can appear, from 1 to 16, for $\mu =4$, applied to the $2^4$ initial sequences (rows). Notice that the total number of rules for this $\mu$-value is $2^{2^4}$ = 65,536, which equal the sum of each row. As it can be observed, the distributions of periods are symmetric to middle rows. Note that the maximum period occurs at the last column ($T=16$) for 16 rules and for every initial condition.

Initial Sequence	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
0000	36,096	3304	4944	4734	5836	3758	2472	1846	1120	758	332	144	80	48	48	16
0001	12,912	6608	9888	9468	9624	6492	3920	2924	1728	1068	440	208	96	80	64	16
0010	11,800	8976	11,780	8457	8976	5697	3552	2803	1634	995	412	200	94	80	64	16
0011	15,368	5320	9490	9252	9296	6397	3702	2981	1756	1067	444	207	96	80	64	16
0100	14,568	5524	11,588	8860	9190	5851	3570	2834	1672	1011	414	200	94	80	64	16
0101	10,520	16,384	8458	6494	8542	5755	3620	2572	1438	919	406	192	80	76	64	16
0110	12,032	6428	12,398	9128	9438	6043	3486	2975	1714	1019	422	199	94	80	64	16
0111	21,376	4956	7416	8125	8242	5637	3580	2641	1648	1025	426	208	96	80	64	16
1000	21,376	4956	7416	8125	8242	5637	3580	2641	1648	1025	426	208	96	80	64	16
1001	12,032	6428	12,398	9128	9438	6043	3486	2975	1714	1019	422	199	94	80	64	16
1010	10,520	16,384	8458	6494	8542	5755	3620	2572	1438	919	406	192	80	76	64	16
1011	14,568	5524	11,588	8860	9190	5851	3570	2834	1672	1011	414	200	94	80	64	16
1100	15,368	5320	9490	9252	9296	6397	3702	2981	1756	1067	444	207	96	80	64	16
1101	11,800	8976	11,780	8457	8976	5697	3552	2803	1634	995	412	200	94	80	64	16
1110	12,912	6608	9888	9468	9624	6492	3920	2924	1728	1068	440	208	96	80	64	16
1111	36,096	3304	4944	4734	5836	3758	2472	1846	1120	758	332	144	80	48	48	16

shows the number of rules that generate sequences with periods in between 1 and $2^4$ for each of the $2^4$ initial sequence of length 4. Note that the distributions of periods are symmetric to middle rows and that the maximum period occurs for only 16 rules, independently of the initial sequence. The proportion of rules as a function of the maximum period of the sequences that each of the $2^{2^4}$ generates over all the initial sequences is depicted in Figure 2 (also for the case $\mu =4$). It is worthy to remark the nonmonotonous shape of this distribution that exhibits three relative maxima at periods $T=1$, $T=3$, and $T=5$. For $T>5$, it seems to decrease exponentially.

Sequences with a 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 [16].

The number of binary de Bruijn sequences for a given $\mu$ is given by $C\left(\mu \right)=2^{2^{\mu -1}-\mu }$ [12,17]. 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, [18,19]).

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. Correspondence betweeen de Bruijn rules and de Bruijn sequences for $\mu =1,2,3$ and 4. The table also shows the Evil Odd Number that divides each de Bruijn rule, leaving the remainder $\varphi \left(\mu \right)$. The Evil Odd Numbers that correspond to de Bruijn rules for $\mu =5$ are presented in Appendix B.

$\mathit{\mu }$	Evil Odd Number	$\mathit{\varphi }\left(\mathit{\mu }\right)$	Rule in Decimal	Rule in Binary	de Bruijn Sequence
1	-	-	1	01	01
2	-	3	3	0011	0011
3	3	15	45	00101101	00010111
3	5	15	75	01001011	00011101
4	3	255	765	0000001011111101	0000101101001111
4	9	255	2295	0000100011110111	0000110100101111
4	15	255	3825	0000111011110001	0000100110101111
4	17	255	4335	0001000011101111	0000111100101101
4	27	255	6885	0001101011100101	0000101111001101
4	29	255	7395	0001110011100011	0000110101111001
4	43	255	10,965	0010101011010101	0000101001101111
4	57	255	14,535	0011100011000111	0000110111100101
4	65	255	16,575	0100000010111111	0000111101001011
4	71	255	18,105	0100011010111001	0000100111101011
4	75	255	19,125	0100101010110101	0000101111010011
4	83	255	21,165	0101001010101101	0000101100111101
4	85	255	21,675	0101010010101011	0000111101011001
4	89	255	22,695	0101100010100111	0000110010111101
4	99	255	25,245	0110001010011101	0000101001111011
4	113	255	28,815	0111000010001111	0000111101100101

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 218,034,945), 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 rules. 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}$ = 65,536 to 16,384.
• 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 [20], multiplied by factors denoted as $\varphi \left(\mu \right)$ (see Appendix A). Let $R_{\mu }$ be a rule for a given $\mu$. Then,

  $$R_{\mu }=\varphi \left(\mu \right)(A+1)$$

  (5)
  In Appendix A, we show that the factor $\varphi \left(\mu \right)$ is

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

  (6)
  For instance, $\varphi \left(2\right)=3$, $\varphi \left(3\right)=15$, $\varphi \left(4\right)=255$, and $\varphi \left(5\right)$ = 65,535. The consideration of this property causes a huge reduction in the feasible set of the de Bruijn rules, from 16,384 to 64 for the case $\mu =4$.
• Evil Odd Number divisibility
  It is also empirical evidence that factor $A+1$ in Equation (5) must be an Evil Odd Number for $R_{\mu }$ to be a de Bruijn rule. For each $\mu$, there is a unique $\varphi$ that divides $R_{\mu }$, which results in multiple remainders that are Evil Odd Numbers. To consider that, it is convenient to denote this factor as $A{\left(\mu \right)}_k$, representing the Evil Odd Numbers for $k=1,2,\dots ,C\left(\mu \right)$. For instance,

  $$A(2,1)=1\times 3=3,A(3,1)=3\times 15=45,A(3,2)=5\times 15=75$$
  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.
  Let $p_{\mu }^j$ be the binary value of the j position in a de Bruijn rule of memory $\mu$. 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 =2(k+1)$, then $p_{2(k+1)}^1=p_{2k+1}^2$ and $p_{2(k+1)}^2=2p_{2(k+1)}^1$.

  for $k=1,2,\dots$.
  This structural condition eliminates $1/4$ of the remaining candidates. For example, for $\mu =3$, these positions are $p_3^1=2$ and $p_3^2=3$. For $\mu =4$, $p_4^1=3$ and $p_4^2=6$, and 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 >3$, the feasible set exceeds the actual number of de Bruijn rules (see

  Table 3. Table resulting from the application of the properties described in Section 4. The second column, $C\left(\mu \right)$, indicates the total number of rules for each value of $\mu$. The third column shows the number of feasible rules remaining after applying the constraints detailed in Section 4. The fourth column lists the number of de Bruijn rules. The remaining columns present ratios between these subsets. Particularly noteworthy is the fifth column, which displays the ratio between the feasible subset and the total number of rules. As $\mu$ increases, the reduction in the search space for de Bruijn rules becomes dramatic — for example, for $\mu =9$, the feasible subset constitutes only about ${10}^{-79}$ of the full rule set.

  $\mathit{\mu }$	$\mathit{C}\left(\mathit{\mu }\right)$	# Feasible	# de Bruijn	Feasible/Total	de Bruijn/Total	de Bruijn/Feasible
  2	16		1		0.0625
  3	256	2	2	0.0078125	0.0078125	1
  4	65,536	24	16	0.000366211	0.00024414	0.66666667
  5	4,294,967,296	6144	2048	1.4305 × 10$-6$	4.7683 × 10$-7$	0.33333333
  6	1.84467 × 1019	402,653,184	67,108,864	2.1827 × 10$-11$	3.6379 × 10$-12$	0.16666667
  7	3.40282 × 1038	1.7293 × 1018	1.4411 × 1017	5.0820 × 10$-21$	4.2351 × 10$-22$	0.08333333
  8	1.15792 × 1077	3.1901 × 1037	1.3292 × 1036	2.7550 × 10$-40$	1.1479 × 10$-41$	0.04166667
  9	1.3408 × 10154	1.0855 × 1076	2.2615 × 1074	8.0964 × 10$-79$	1.6867 × 10$-80$	0.02083333

  ).
• 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.

Let us summarize the reduction procedure that results from the application of these properties for the case $\mu =4$. There are 65,536 rules that are filtered as follows:

• After applying the boundary conditions, 16,384 rules remain feasible.
• Applying symmetry, i.e., dividing by $\varphi \left(4\right)=255$, 64 rules remain.
• The requirement that the remainder is an Evil Odd Number reduces the previous number to 32 rules.
• Verifying the constrained position pairs reduces the feasible set to 24 rules.

From these 24 feasible rules, only 16 are de Bruijn (see Table 2).

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 (an example can be found in Appendix C). 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 [21]. 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. Evaluation metrics for the neural network models applied to classify the de Bruijn rules for memories with $\mu =5$ and $\mu =6$. Total refers to the sumTP + FP + TN + FN and corresponds to one fifth of the whole dataset. The positive class considered 1 → de Bruijn.

Metric, Definition	$\mathit{\mu }=5$	$\mathit{\mu }=6$
True Positives (TP)	397	198,563
False Positives (FP)	3	19,839
True Negatives (TN)	820	180,668
False Negatives (FN)	9	930
Accuracy, (TP + TN)/Total	0.9902	0.9481
Sensitivity (Recall), TP/(TP + FN)	0.9778	0.9953
Specificity, TN/(TN + FP)	0.9964	0.9011
Precision (PPV), TP/(TP + FP)	0.9925	0.9092
Negative Predictive Value (NPV), TN/(TN + FN)	0.9891	0.9949
Balanced Accuracy, (Sens. + Spec.)/2	0.9871	0.9482
Detection Rate, TP/Total	0.3230	0.4964
Detection Prevalence, (TP + FP) / Total	0.3255	0.5460
True Prevalence, (TP + FN) / Total	0.3303	0.4987

).

We implemented a binary classification model using a feedforward neural network in R (version 4.5.0) [22]. 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 (bit₁ to ${\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 were randomly split into training (80%) and testing (20%) subsets to evaluate model performance on unseen data. The validation set was chosen to be $20\%$ of the training set in all cases.
• Model specification and training: A feedforward neural network was constructed using the keras package (version 2.15.0) with a TensorFlow (version 2.16.0) backend [22,23].

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 the following:

• 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. To get this sample of the feasible rule space, we used brute force to generate 1 million de Bruijn rules. In parallel, we generated a larger number of non-de Bruijn feasible rules and randomly selected 1 million of them. Note that the ratio of de Bruijn to feasible rules is about 0.17 (Table 3), which means that approximately 6 million feasible rules must be generated by brute force to obtain 1 million de Bruijn rules.

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, with 20% used for validation 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 and 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 in 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 a nearly complete classification of the 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 one to find the granddaddy sequence that represents the lexicographically smallest member for each $\mu$-value.

The rule-based approach for generating de Bruijn sequences presented in this paper is, to the best of our knowledge, unique in the literature. It employs a hybrid methodology that integrates machine learning techniques within the framework of cellular automata. Specifically, we use rules with memory $\mu$ to generate sequences from an initial configuration of $\mu$ bits. Rules that generate sequences with a maximum period $T=2^{\mu }$—the so-called de Bruijn sequences—are referred to as the de Bruijn rules. By characterizing these rules based on certain empirical properties, we achieve a significant reduction in the overall rule set. However, even after this reduction, a huge set of feasible rules remains for larger $\mu$-values, which still needs to be classified. To address this, we employ a neural network, which has been shown to perform well for $\mu =5$ and $\mu =6$. We believe that further development of this machine learning methodology can yield excellent results for computing de Bruijn sequences with much larger $\mu$-values. It is also worth noting that existing methods based on Nonlinear Feedback Shift Registers have yet to definitively solve the problem. Thus, we consider the results presented in this paper a significant advancement in the study and generation of this important class of sequences.