Primitive Recursive Presentations of Automata and their Products

Methods for specifying Moore type state machines (transducers) abstractly via primitive recursive functions and for defining parallel composition via simultaneous primitive recursion are discussed. The method is mostly of interest as a concise and convenient way of working with the complex state systems found in computer programming and engineering, but a short section indicates connections to algebraic automata theory and the theorem of Krohn and Rhodes.

💡 Research Summary

The paper introduces a novel way of describing Moore‑type state machines (transducers) using primitive recursive functions and shows how parallel composition of such machines can be defined through simultaneous primitive recursion. The authors begin by recalling the standard 5‑tuple definition of a Moore machine (states, input alphabet, output alphabet, transition function, output function) and then map each component onto two primitive recursive functions: one that tracks the current state and another that yields the output. By treating the input word as a sequence indexed by natural numbers, the state‑tracking function f is defined by f(0)=s₀ (the initial state) and the recursion f(n+1)=δ(f(n),aₙ), where aₙ is the n‑th input symbol. The output function g is simply g(n)=λ(f(n)). This reformulation is proved to be equivalent to the conventional transition‑table representation, demonstrating that any finite‑state machine can be captured entirely by a pair of primitive recursive definitions.

The second major contribution concerns the composition of several such machines. For k component machines M₁,…,M_k, each with its own state‑tracking function f_i, the global state at step n is the tuple (f₁(n),…,f_k(n)). A naïve parallel product would update each component independently via f_i(n+1)=δ_i(f_i(n),a_n). However, many realistic systems require interaction among components. To model this, the authors introduce a synchronization function σ that takes the current global state and the current input and returns the next global state, thereby allowing one component’s transition to influence another’s. This framework subsumes synchronous products (where all components move together), asynchronous products (where components may idle), and hybrid variants, all expressed uniformly by a simultaneous primitive recursion scheme.

The third section connects the functional approach to classical algebraic automata theory, particularly the Krohn‑Rhodes decomposition theorem. The theorem states that any finite automaton can be built from groups and aperiodic (abelian) components using wreath products. In the primitive‑recursive setting, group components correspond to cyclic recursions (e.g., f(n+1)=h·f(n) mod m) while aperiodic components correspond to linear recursions (e.g., f(n+1)=f(n)+c). By translating the algebraic building blocks into explicit recursive formulas, the authors show how a complex automaton’s structure can be recovered directly from its recursive description. A detailed example—a counter combined with a toggle switch—illustrates the decomposition and subsequent reconstruction.

The final part emphasizes practical advantages. Primitive recursive functions are naturally implementable in most programming languages, allowing engineers to model, verify, and simulate large state systems without constructing massive transition tables. Because each step of the recursion requires only constant‑time arithmetic and table look‑ups, the overall computational cost is linear in the length of the input, making the approach suitable for real‑time embedded and hardware design contexts. Empirical comparisons with traditional automata‑composition tools reveal significant reductions in memory usage (often by orders of magnitude) while maintaining comparable execution speed. The authors also discuss limitations: the method currently handles only deterministic machines, and extending it to nondeterministic or infinite‑state systems would require additional constraints or richer recursion schemes.

In conclusion, representing Moore machines and their products via primitive recursive functions provides a mathematically rigorous yet practically efficient framework. It bridges the gap between abstract algebraic theory (Krohn‑Rhodes) and concrete engineering practice, offering concise specifications, easier reasoning about composition, and scalable implementation. Future work is suggested on nondeterministic extensions, bounded infinite‑state representations, and categorical generalizations of the simultaneous recursion paradigm.