Universal FSA Emulation by Neural Finite-State Machines

• Universal FSA Emulation is a method where finite-depth feedforward ReLU and threshold networks simulate any deterministic finite automaton by encoding state transitions for bounded-length inputs.
• It employs explicit layerwise constructions, including one-hot and binary encodings with two-layer transition modules, to implement regular language recognition.
• The approach demonstrates exponential state compression, latent embeddings of Myhill–Nerode equivalence classes, and a formal expressivity boundary for fixed-depth networks.

Universal finite-state automaton (FSA) emulation refers to the capacity of certain neural network architectures—specifically, finite-depth feedforward ReLU and threshold networks—to exactly simulate any deterministic finite automaton (DFA) on bounded-length inputs, thus acting as "neural finite-state machines" (N-FSMs). This is achieved through explicit layerwise constructions that encode DFA state transitions in the network’s depth, enabling precise realization of regular languages and delineating a formal expressivity boundary for such networks. The central results formalize layer and parameter requirements, provide state compression strategies, establish embeddings of Myhill–Nerode equivalence classes into continuous latent spaces, and rigorously show that fixed-depth networks cannot recognize non-regular languages (Dhayalkar, 16 May 2025).

1. Definition and Theoretical Framework

A deterministic finite automaton is defined as a 5-tuple $M = (Q, \Sigma, \delta, q_0, F)$, where $Q$ is a finite set of $n$ states, $\Sigma$ a finite input alphabet of size $k$, $\delta: Q \times \Sigma \to Q$ the deterministic transition function, $q_0 \in Q$ the initial state, and $F \subseteq Q$ the accepting states. On input $x = s_1 s_2 \cdots s_T \in \Sigma^T$, the DFA recursively applies $h_t = \delta(h_{t-1}, s_t)$ for $Q$0 and accepts if $Q$1.

An N-FSM corresponding to $Q$2 is a feedforward network $Q$3 satisfying $Q$4 if $Q$5 and $Q$6 otherwise. At each network layer, the hidden representation encodes the DFA state and the final layer tests for membership in $Q$7 (Dhayalkar, 16 May 2025).

2. Explicit Construction of Feedforward Emulators

Given a DFA $Q$8, the emulation proceeds through explicit neural architectures:

2.1. One-Hot Encodings

• Symbols: Each $Q$9 is represented by $n$0.
• States: Each $n$1 is mapped to $n$2.
• At step $n$3, the hidden state $n$4 is concatenated with $n$5 to form the input to the transition module.

2.2. Two-Layer Transition Modules

• Hidden Layer: For each $n$6, an “AND-unit” $n$7 ensures activation if and only if the network is in state $n$8 and receives symbol $n$9.
• Output Layer: The next state $\Sigma$0 is computed as a sum over the activated $\Sigma$1, with weights $\Sigma$2 iff $\Sigma$3.

2.3. Readout Layer

Once $\Sigma$4 symbols are processed, the network produces $\Sigma$5. The indicator $\Sigma$6 (with $\Sigma$7 iff $\Sigma$8) determines acceptance.

2.4. Depth and Width Bounds

Construction	Depth $\Sigma$9	Width $k$0
One-hot + ReLU	$k$1	$k$2
Binary + threshold	$k$3	$k$4

The construction ensures exact simulation for all $k$5 of length $k$6. For inputs restricted to at most $k$7 symbols, $k$8.

3. Exponential State Compression

State encodings can be exponentially compressed by representing DFA states as $k$9-bit binary codes:

• Binary State Encoding: Map each $\delta: Q \times \Sigma \to Q$0 to $\delta: Q \times \Sigma \to Q$1 with $\delta: Q \times \Sigma \to Q$2.
• Transition Realization: Each output bit $\delta: Q \times \Sigma \to Q$3 is a Boolean function $\delta: Q \times \Sigma \to Q$4 specifying the $\delta: Q \times \Sigma \to Q$5-th bit of $\delta: Q \times \Sigma \to Q$6.
• Threshold Circuits: Classical results guarantee a depth-2 threshold circuit for any finite Boolean function. Each bit is realized via threshold gates.

This approach achieves hidden-state width $\delta: Q \times \Sigma \to Q$7. Depth and overall layer width are preserved at $\delta: Q \times \Sigma \to Q$8 and $\delta: Q \times \Sigma \to Q$9, respectively (Dhayalkar, 16 May 2025).

4. Myhill–Nerode Equivalence and Latent Embeddings

The Myhill–Nerode relation partitions strings into equivalence classes corresponding to DFA states:

• Embedding Theorem: There exists a feedforward network $q_0 \in Q$0 such that $q_0 \in Q$1 iff $q_0 \in Q$2. If $q_0 \in Q$3, then $q_0 \in Q$4.
• Construction: Run DFA simulation to obtain $q_0 \in Q$5, then project using $q_0 \in Q$6 mapping each $q_0 \in Q$7 to distinct $q_0 \in Q$8 in $q_0 \in Q$9.
• Johnson–Lindenstrauss Compression: The set $F \subseteq Q$0 can be further reduced to dimension $F \subseteq Q$1 while preserving linear separability, thus embedding equivalence classes in low-dimensional latent space (Dhayalkar, 16 May 2025).

5. Expressivity Limitations: Boundary for Regular Languages

Feedforward networks of fixed depth and width possess a finite partitioning capacity:

• Linear Region Bound: For depth $F \subseteq Q$2 and width $F \subseteq Q$3, any such network partitions input space $F \subseteq Q$4 into $F \subseteq Q$5 regions.
• Non-Regular Language Limitation: Languages such as $F \subseteq Q$6 require capacity for infinitely many regions, which exceeds what is possible for fixed $F \subseteq Q$7 and $F \subseteq Q$8. Thus, such networks cannot recognize non-regular languages.
• Formal Lower Bound: For every such network, there exists $F \subseteq Q$9 such that, for all $x = s_1 s_2 \cdots s_T \in \Sigma^T$0, correct classification of all strings in $x = s_1 s_2 \cdots s_T \in \Sigma^T$1 is impossible. Only regular languages are exactly recognizable (Dhayalkar, 16 May 2025).

6. Synthesis of Results and Architectural Trade-Offs

Emulation Mode	Depth $x = s_1 s_2 \cdots s_T \in \Sigma^T$2	Width $x = s_1 s_2 \cdots s_T \in \Sigma^T$3	State Width
One-hot encoding + ReLU	$x = s_1 s_2 \cdots s_T \in \Sigma^T$4	$x = s_1 s_2 \cdots s_T \in \Sigma^T$5	$x = s_1 s_2 \cdots s_T \in \Sigma^T$6
Binary encoding + threshold	$x = s_1 s_2 \cdots s_T \in \Sigma^T$7	$x = s_1 s_2 \cdots s_T \in \Sigma^T$8	$x = s_1 s_2 \cdots s_T \in \Sigma^T$9
Myhill–Nerode embedding	$h_t = \delta(h_{t-1}, s_t)$0	$h_t = \delta(h_{t-1}, s_t)$1	$h_t = \delta(h_{t-1}, s_t)$2

• State Compression: Exponential compression from $h_t = \delta(h_{t-1}, s_t)$3-dim. one-hot to $h_t = \delta(h_{t-1}, s_t)$4-bit binary without sacrificing expressivity for finite-state computations.
• Latent Embeddings: Faithful, linearly-separable vectorial mapping of equivalence classes, with further dimension reduction via random projection possible.
• Expressivity Boundary: The constructive approach delineates that regular languages are both the upper and lower bounds of what N-FSMs can recognize with fixed architecture.
• Bridging Symbolic and Neural Computation: These results rigorously instantiate a blueprint for realizing symbolic algorithms within neural architectures (Dhayalkar, 16 May 2025).

7. Context and Significance

The established equivalence between neural finite-state machines and DFAs provides a mathematically precise characterization of neural network capacity in symbolic sequence processing, automata simulation, and neural-symbolic integration. The constructive nature of the methods contrasts with prior heuristic or probing-based analyses, supplying explicit network weights, architectures, and representations. This formalization enables principled design of neural models for tasks where regular language structure is fundamental, while also identifying exact limits for problems involving unbounded memory or non-regular languages. As such, universal FSA emulation serves as a foundational result, bridging disciplines and informing further research on the correspondence between discrete automata and continuous neural computation (Dhayalkar, 16 May 2025).