automata: A Python package for simulating and manipulating automata

Summary Automata are abstract machines used to represent models of computation, and are a central object of study in theoretical computer science (J


Statement of need
Automata are a core component of both computer science education and research, seeing further theoretical work and applications in a wide variety of areas such as computational biology (Marschall, 2011) and networking (Xu et al., 2016).Consequently, the manipulation of automata with software packages has seen significant attention from researchers in the past.The similarly named Mathematica package Automata (Sutner, 2003) implements a number of algorithms for use with finite-state automata, including regular expression conversion and binary set operations.In Java, the Brics package (Møller, 2021) implements similar algorithms, while the JFLAP package (Rodger, 2006) places an emphasis on interactivity and simulation of more general families of automata.
automata serves the demand for such a package in the Python software ecosystem, implementing algorithms and allowing for simulation of automata in a manner comparable to the packages described previously.As a popular high-level language, Python enables significant flexibility and ease of use that directly benefits many users.The package includes a comprehensive test suite, support for modern language features (including type annotations), and has a large number of different automata, meeting the demands of users across a wide variety of use cases.In particular, the target audience is both researchers that wish to manipulate automata, and for those in educational contexts to reinforce understanding about how these models of computation function.

The automata package
The API of the package is designed to mimic the formal mathematical description of each automaton using built-in Python data structures (such as sets and dicts).This is for ease of use by those that are unfamiliar with these models of computation, while also providing performance suitable for tasks arising in research.In particular, algorithms in the package have been written for tackling performance on large inputs, incorporating optimizations such as only exploring the reachable set of states in the construction of a new finite-state automaton.The package also has native display integration with Jupyter notebooks, enabling easy visualization that allows students to interact with automata in an exploratory manner.
Of note are some commonly used and technical algorithms implemented in the package for finite-state automata: • An optimized version of the Hopcroft-Karp algorithm to determine whether two deterministic finite automata (DFA) are equivalent (Almeida et al., 2010).
• The product construction algorithm for binary set operations (union, intersection, etc.) on the languages corresponding to two input DFAs (Sipser, 2012).
• A specialized algorithm for directly constructing a state-minimal DFA accepting a given finite language (Mihov & Schulz, 2019).
• A specialized algorithm for directly constructing a minimal DFA recognizing strings containing a given substring (Knuth et al., 1977).
To the authors' knowledge, this is the only Python package implementing all of the automata manipulation algorithms stated above.
automata has already been cited in publications (Jeff Erickson & Solomon, 2023), and has seen use in multiple large undergraduate courses in introductory theoretical computer science at the University of Illinois Urbana-Champaign (roughly 2000 students since Fall 2021).In this instance, the package is being used both as part of an autograder utility for finite-state automata created by students, and as an exploratory tool for use by students directly.

Example usage
Figure 1: A visualization of target_words_dfa.Transitions on characters leading to immediate rejections are omitted.
The following example is inspired by the use case described in Johnson (2010).We wish to determine which strings in a given set are within the target edit distance to a reference string.
We will first initialize a DFA corresponding to a fixed set of target words over the alphabet of all lowercase ascii characters.
Next, we construct an NFA recognizing all strings within a target edit distance of a fixed reference string, and then immediately convert this to an equivalent DFA.The package provides builtin functions to make this construction easy, and we use the same alphabet as the DFA that was just created.Finally, we take the intersection of the two DFAs we have constructed and read all of the words in the output DFA into a list.The library makes this straightforward and idiomatic.The DFA found_words_dfa accepts strings in the intersection of the languages of the DFAs given as input, and found_words is a list containing this language.Note the power of this technique is that the DFA words_within_edit_distance_dfa has an infinite language, meaning we could not do this same computation just using the builtin sets in Python directly (as they always represent a finite collection), although the syntax used by automata is very similar to promote intuition.