[Paper Review] Primitive Recursive Presentations of Automata and their Products

Victor Yodaiken|arXiv (Cornell University)|Jul 23, 2009

semigroups and automata theory3 references3 citations

TL;DR

This paper introduces a primitive recursive functional representation of Moore machines (transducers) that enables concise, parameterized specification of complex state systems, particularly for compositional and concurrent architectures. By modeling state transitions through simultaneous recursion over input strings and feedback, the method supports modular construction of parallel systems and establishes connections to algebraic automata theory, including Krohn-Rhodes decomposition and monoid factorization.

ABSTRACT

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.

Motivation & Objective

• To address the limitations of traditional finite automata representations in specifying large, complex, and partially specified state systems in programming and engineering.
• To provide a parameterized, concise, and composable method for defining system architectures using string functions defined by primitive recursion.
• To formalize the composition of parallel and concurrent state machines through feedback-driven recursive function systems.
• To explore connections between recursive function representations and algebraic automata theory, particularly the Krohn-Rhodes theorem and monoid factorization.
• To demonstrate practical applicability through examples like stack machines and ripple-carry adders, showing how recursive composition models real-world system behavior.

Proposed method

• Representing a Moore machine as a string function f: A* → X, where f(Λ) = x₀ and f(wa) = h(a, f(w)) using primitive recursion.
• Defining composite systems via simultaneous recursion: f(w) = h(f₁(u₁), ..., fₙ(uₙ)), with uᵢ(wa) = uᵢ(w) ∘ g(i, a, f(w)) to model feedback-driven input generation.
• Using a communication map g to route inputs to components based on current system state (feedback), enabling dynamic interaction between components.
• Constructing systems as products of simpler machines, where each component's input sequence uᵢ depends on prior outputs and external inputs through recursive feedback.
• Applying the method to model real systems such as stacks and ripple-carry adders, showing how recursive composition captures hardware-level behavior.
• Establishing a monoid structure from string equivalence classes [w]_f, where [w]·[z] = [w∘z], to link functional representations to algebraic automata theory.

Experimental results

Research questions

• RQ1 Can complex, concurrent, and partially specified state systems be more concisely and modularly specified using recursive string functions rather than traditional state-set representations?
• RQ2 How can feedback from component outputs be systematically encoded in recursive function definitions to model parallel state transitions?
• RQ3 What is the relationship between the primitive recursive representation of a composite system and the underlying algebraic structure of its state monoid?
• RQ4 Can the Krohn-Rhodes decomposition theorem be naturally realized through recursive composition of simpler transducers?
• RQ5 To what extent do group-like components in state machines (e.g., in circular buffers) correspond to invertible or undoable operations in the recursive framework?

Key findings

• A functional representation via primitive recursion allows for the concise and parameterized specification of Moore machines, abstracting away from explicit state sets.
• Composite systems can be constructed using simultaneous recursion where each component's input sequence depends on feedback, enabling modeling of concurrent and interacting state machines.
• The method supports the construction of finite-state systems from simpler finite-state components, and any finite-state transducer can be represented as a product of 2-state Moore machines using binary encoding.
• The monoid determined by a string function f is finite if and only if the set of functions {f_w | f_w(z) = f(w∘z)} is finite, linking functional behavior to algebraic structure.
• Cascade compositions (e.g., ripple-carry adders) model sequential data propagation and correspond to monoid factorizations, but may be slow due to carry propagation, highlighting trade-offs in system design.
• Group-like components (e.g., in circular buffers) suggest the possibility of partial inverses, indicating that recursive decomposition may reveal undoable or reversible operations in system behavior.