Deterministic Finite Automata Research Articles

Binary Coded Unary Regular Languages

[Formula: see text] is a binary coded unary regular language, if there exists a unary regular language [Formula: see text] such that [Formula: see text] is in [Formula: see text] if and only if the binary representation of [Formula: see text] is in [Formula: see text]. If a unary language [Formula: see text] is accepted by a minimal deterministic finite automaton (DFA) [Formula: see text] with [Formula: see text] states, then its binary coded version [Formula: see text] is regular and can be accepted by a DFA [Formula: see text] using at most [Formula: see text] states, but at least [Formula: see text] states. There are witness languages matching these upper and lower bounds exactly, for each [Formula: see text]. More precisely, if [Formula: see text] uses [Formula: see text] states in the initial segment and [Formula: see text] states in the loop, where [Formula: see text] is odd and [Formula: see text], then the minimal [Formula: see text] for [Formula: see text] consists of a preamble with at most [Formula: see text] but at least [Formula: see text] states, except for [Formula: see text] with no preamble, and a kernel with at most [Formula: see text] but at least [Formula: see text] states. Also these lower bounds are matched exactly by witness languages, for each [Formula: see text]. If the length of the loop is fixed, the size of the preamble is bounded by [Formula: see text]. The conversion in the opposite way is not always granted: there are binary regular languages the unary versions of which are not even context free. The conversion of a unary nondeterministic finite automaton (NFA) to a binary NFA uses [Formula: see text] states and introduces a binary version of Chrobak normal form.

Latvian Quantum Finite State Automata for Unary Languages

We design Latvian quantum finite state automata (LQFAs) recognizing unary regular languages with isolated cut point [Formula: see text]. From an architectural viewpoint, we suitably combine two LQFAs recognizing with isolated cut point, respectively, the finite part and the ultimately periodic part any given unary regular language [Formula: see text] consists of. In particular, both these LQFAs incorporate a sub-module discriminating strings on the basis of their length. Both the number of basis states and the isolation around the cut point of the resulting LQFAs for [Formula: see text] exponentially depend on the size of the minimal deterministic finite state automaton for [Formula: see text]. Moreover, the recognition of [Formula: see text] tends to becoming deterministic as the number of the basis states employed in the length-discriminating sub-module grows.

Automatic Abelian Complexities of Parikh-Collinear Fixed Points

AbstractParikh-collinear morphisms have the property that all the Parikh vectors of the images of letters are collinear, i.e., the associated adjacency matrix has rank 1. In the conference DLT–WORDS 2023 we showed that fixed points of Parikh-collinear morphisms are automatic. We also showed that the abelian complexity function of a binary fixed point of such a morphism is automatic under some assumptions. In this note, we fully generalize the latter result. Namely, we show that the abelian complexity function of a fixed point of an arbitrary, possibly erasing, Parikh-collinear morphism is automatic. Furthermore, a deterministic finite automaton with output generating this abelian complexity function is provided by an effective procedure. To that end, we discuss the constant of recognizability of a morphism and the related cutting set.

HybridSA: GPU Acceleration of Multi-pattern Regex Matching using Bit Parallelism

Multi-pattern matching is widely used in modern software for applications requiring high throughput such as protein search, network traffic inspection, virus or spam detection. Graphics Processor Units (GPUs) excel at executing massively parallel workloads. Regular expression (regex) matching is typically performed by simulating the execution of deterministic finite automata (DFAs) or nondeterministic finite automata (NFAs). The natural implementations of these automata simulation algorithms on GPUs are highly inefficient because they give rise to irregular memory access patterns. This paper presents HybridSA, a heterogeneous CPU-GPU parallel engine for multi-pattern matching. HybridSA uses bit parallelism to efficiently simulate NFAs on GPUs, thus reducing the number of memory accesses and increasing the throughput. Our bit-parallel algorithms extend the classical shift-and algorithm for string matching to a large class of regular expressions and reduce automata simulation to a small number of bitwise operations. We have developed a compiler to translate regular expressions into bit masks, perform optimizations, and choose the best algorithms to run on the GPU. The majority of the regular expressions are accelerated on the GPU, while the patterns that exhibit random memory accesses are executed on the CPU in parallel. We evaluate HybridSA against state-of-the-art CPU and GPU engines, as well as a hybrid combination of the two. HybridSA achieves between 4 and 60 times higher throughput than the state-of-the-art CPU engine and between 4 and 233 times better than the state-of-the-art GPU engine across a collection of real-world benchmarks.

Polynomial crisp-minimization algorithm for fuzzy deterministic automata

Designing automata minimization algorithms is a significant topic in Automata Theory and Languages with practical applications. In this paper, we develop an efficient minimization algorithm for deterministic fuzzy finite automata over locally finite lattices. More precisely, the algorithm outputs an equivalent minimal crisp-deterministic fuzzy finite automaton for an input fuzzy deterministic finite automaton (FDfA). The running time of the proposed algorithm is polynomial for particular types of locally finite lattices, specifically for max-min-based complete residuated lattices. The intuition behind the proposed algorithm relies on the polynomial minimization algorithm's intuition for ordinary deterministic automata developed by Vazquez de Parga, Garcia, and Lopez (2013) [35]. The motivation for this study comes from the fact that the original algorithm's notions and meanings are lost in the context of fuzzy automata. Thus, we establish a new theoretical foundation that provides the correctness and the polynomial-time nature of this new crisp-minimization algorithm for FDfAs.

P4Rex: Accelerating regular expression matching with programmable switches

Regular expression matching is pivotal in numerous network applications. With the ever-increasing scale of data center traffic, deploying regular expression matching modules on traditional servers struggles to meet throughput demands. Emerging programmable switches have brought new prospects for high-speed pattern matching. However, deploying regular expression matching onto programmable switches presents the challenge of space explosion incurred by compiling regular expressions into a Deterministic Finite Automata (DFA). In this paper, we introduce P4Rex, a regular expression matching system designed for programmable switches. P4Rex synergistically leverages two following techniques: an efficient regular expression grouping algorithm that partitions regular expressions into different groups to reduce memory consumption, and DFA compression technology to achieve transition sharing. Experimental results demonstrate that P4Rex exhibits an average improvement of 17% and maximum improvement of 30% on memory consumption compared to prior regular expression grouping schemes and saves more than 10x memory consumption compared to deploying DFA directly on programmable switch.

Deterministic One-Way Simulation of Two-Way Deterministic Finite Automata Over Small Alphabets

It is shown that a two-way deterministic finite automaton (2DFA) with [Formula: see text] states over an alphabet [Formula: see text] can be transformed to an equivalent one-way automaton (1DFA) with [Formula: see text] states, where [Formula: see text]. This reflects the fact that, by keeping the last processed symbol [Formula: see text] in memory, the simulating 1DFA can remember one of [Formula: see text] states in which the automaton moves by [Formula: see text] to the right, and a function that maps [Formula: see text] states moving to the left to [Formula: see text] states moving to the right; cf. ca. [Formula: see text] functions in the classical construction. A close lower bound of [Formula: see text] states is established using a 2-symbol alphabet, with witness languages defined by direction-determinate 2DFA. The same lower bound is also achieved with witness languages defined by sweeping 2DFA, at the expense of using a 5-symbol alphabet. In addition, the complexity of transforming a sweeping or a direction-determinate 2DFA to a 1DFA is shown to be exactly [Formula: see text].

VIRTSI: A novel trust dynamics model enhancing Artificial Intelligence collaboration with human users – Insights from a ChatGPT evaluation study

The rapid integration of intelligent processes and methods into information systems in the Artificial Intelligence (AI) era has led to a substantial shift towards autonomous software decision-making. This evolution necessitates robust human oversight, especially in critical domains like Healthcare, Education, and Energy. Human trust in AI plays a vital role in influencing decision-making processes of users interacting with AI.This paper presents VIRTSI (Variability and Impact of Reciprocal Trust States towards Intelligent systems), a novel rigorous computational model for human-AI Interaction. VIRTSI simulates human trust states, spanning from overtrust to distrust, through user modelling. It comprises: 1. A trust dynamics representational model based on Deterministic Finite State Automata (DFAs), illustrating transitions among cognitive trust states in response to AI-generated replies. 2. A trust evaluation model based on Confusion Matrices, originating from machine learning and Accuracy Metrics, providing a quantitative framework for analysing human trust dynamics. As a result, this is the first time that trust dynamics have been thoroughly traced in a representational model and a method has been developed to assess the impact of possibly harmful states like overtrust and distrust.An empirical study on the recently launched Large Language Model of generative AI, ChatGPT (version 3.5), provides a radical underexplored AI-generated platform for evaluating the human-AI interaction through VIRTSI. The study involved 1200 interactions of real users as well as AI experts together with experts in two very different domains of evaluation, namely software engineering and poetry. This study traces trust dynamics and the emerging human-AI interaction, in concrete examples of real user synergies with generative AI. The research reveals the vital role of maintaining normal trust states for optimal human-AI interaction and that both AI and human users need further steps towards this goal. The real-world implications of this research can guide the creation and evaluation of user interfaces with AI and the incorporation of functionalities in the development of generative AI chatbots in terms of trust by providing a new rigorous DFA representational method of trust dynamics and a corresponding new perspective of confusion matrix evaluation method of the dynamics’ impact in the efficiency of human-AI dialogues.

Thermodynamics of Computations with Absolute Irreversibility, Unidirectional Transitions, and Stochastic Computation Times

Developing a thermodynamic theory of computation is a challenging task at the interface of nonequilibrium thermodynamics and computer science. In particular, this task requires dealing with difficulties such as stochastic halting times, unidirectional (possibly deterministic) transitions, and restricted initial conditions, features common in real-world computers. Here, we present a framework which tackles all such difficulties by extending the martingale theory of nonequilibrium thermodynamics to generic nonstationary Markovian processes, including those with broken detailed balance and/or absolute irreversibility. We derive several universal fluctuation relations and second-law-like inequalities that provide both lower and upper bounds on the intrinsic dissipation (mismatch cost) associated with any periodic process—in particular, the periodic processes underlying all current digital computation. Crucially, these bounds apply even if the process has stochastic stopping times, as it does in many computational machines. We illustrate our results with exhaustive numerical simulations of deterministic finite automata processing bit strings, one of the fundamental models of computation from theoretical computer science. We also provide universal equalities and inequalities for the acceptance probability of words of a given length by a deterministic finite automaton in terms of thermodynamic quantities, and outline connections between computer science and stochastic resetting. Our results, while motivated from the computational context, are applicable far more broadly. Published by the American Physical Society 2024

Incremental NFA minimization

We tackle the (classic) problem of minimizing (non)deterministic finite automata. The algorithm we put forward has the peculiarity of being incremental, i.e., the minimization proceeds by successive iterations, each producing a partially minimized automaton language-equivalent to the input one.Our algorithm builds upon Almeida et al. from 2014, fixing a minor mistake and generalizing it to the nondeterministic case. It relies on a colouring procedure of a graph associated to the automaton, keeping track of partial information. After dealing with the deterministic case, we extend this idea to the bisimulation-minimization of nondeterministic automata.The algorithms for both the deterministic and the nondeterministic cases run in time O(nm) for an automaton with n states and m transitions. The complexity for the deterministic case matches the complexity claimed by Almeida et al.. The nondeterministic case improves the fastest known incremental algorithm for this problem.We conclude introducing and using a notion of signature of a state, whose aim is to exploit pre-computed information potentially available, to speed-up the process. A signature is used to produce an initial partition of the automaton's states and can be easily integrated in both the incremental and the non-incremental algorithm.

Yet another canonical nondeterministic automaton

Several canonical forms of finite automata have been introduced over the decades. In particular, if one considers the minimal deterministic finite automaton (DFA), the canonical residual finite state automaton (RFSA), and the átomaton of a language, then the átomaton can be seen as the dual automaton of the minimal DFA, but no such dual has been presented for the canonical RFSA so far. We fill this gap by introducing a new canonical automaton that we call the maximized prime átomaton, and study its properties. We also describe how these four automata can be extracted from suitable observation tables used in the automata learning context.

Zombie cheminformatics: extraction and conversion of Wiswesser Line Notation (WLN) from chemical documents

PurposeWiswesser Line Notation (WLN) is a old line notation for encoding chemical compounds for storage and processing by computers. Whilst the notation itself has long since been surpassed by SMILES and InChI, distribution of WLN during its active years was extensive. In the context of modernising chemical data, we present a comprehensive WLN parser developed using the OpenBabel toolkit, capable of translating WLN strings into various formats supported by the library. Furthermore, we have devised a specialised Finite State Machine l, constructed from the rules of WLN, enabling the recognition and extraction of chemical strings out of large bodies of text. Available open-access WLN data with corresponding SMILES or InChI notation is rare, however ChEMBL, ChemSpider and PubChem all contain WLN records which were used for conversion scoring. Our investigation revealed a notable proportion of inaccuracies within the database entries, and we have taken steps to rectify these errors whenever feasible.Scientific contributionTools for both the extraction and conversion of WLN from chemical documents have been successfully developed. Both the Deterministic Finite Automaton (DFA) and parser handle the majority of WLN rules officially endorsed in the three major WLN manuals, with the parser showing a clear jump in accuracy and chemical coverage over previous submissions. The GitHub repository can be found here: https://github.com/Mblakey/wiswesser.

A Learning-Based Approach for Diagnosis and Diagnosability of Unknown Discrete Event Systems.

This article develops a novel active-learning technique for fault diagnosis of an initially unknown finite-state discrete event system (DES). The proposed method constructs a diagnosis tool (termed diagnoser), which is able to detect and identify occurred faults by tracking the observable behaviors of the system under diagnosis. The proposed algorithm utilizes an active-learning mechanism to incrementally collect the information about the system to construct the diagnoser. This is achieved by completing a series of observation tables in a systematic way, resulting in the construction of the diagnoser. It is proven that the proposed algorithm terminates after a finite number of iterations and returns a correctly conjectured diagnoser. The developed diagnoser is a deterministic finite-state automaton. Furthermore, we have proven that the developed diagnoser consists of a minimum number of states. A sufficient condition for diagnosability of the system under diagnosis is derived, which guarantees the diagnosis of faults within a bounded number of observations. The developed method is applied to two case-studies, illustrating the steps of the proposed algorithm and its capability of diagnosing multiple faults.

Analyzing Robustness of Angluin's L$^*$ Algorithm in Presence of Noise

Angluin's L$^*$ algorithm learns the minimal deterministic finite automaton (DFA) of a regular language using membership and equivalence queries. Its probabilistic approximatively correct (PAC) version substitutes an equivalence query by numerous random membership queries to get a high level confidence to the answer. Thus it can be applied to any kind of device and may be viewed as an algorithm for synthesizing an automaton abstracting the behavior of the device based on observations. Here we are interested on how Angluin's PAC learning algorithm behaves for devices which are obtained from a DFA by introducing some noise. More precisely we study whether Angluin's algorithm reduces the noise and produces a DFA closer to the original one than the noisy device. We propose several ways to introduce the noise: (1) the noisy device inverts the classification of words w.r.t. the DFA with a small probability, (2) the noisy device modifies with a small probability the letters of the word before asking its classification w.r.t. the DFA, (3) the noisy device combines the classification of a word w.r.t. the DFA and its classification w.r.t. a counter automaton, and (4) the noisy DFA is obtained by a random process from two DFA such that the language of the first one is included in the second one. Then when a word is accepted (resp. rejected) by the first (resp. second) one, it is also accepted (resp. rejected) and in the remaining cases, it is accepted with probability 0.5. Our main experimental contributions consist in showing that: (1) Angluin's algorithm behaves well whenever the noisy device is produced by a random process, (2) but poorly with a structured noise, and, that (3) is able to eliminate pathological behaviours specified in a regular way. Theoretically, we show that randomness almost surely yields systems with non-recursively enumerable languages.

Identification of labeled Petri nets from finite automata

Automata and Petri nets are two typical models of discrete event systems. The paper studies the problem of converting a finite automaton into a Petri net that satisfies the specified structural features. More specifically, we identify a labeled Petri net from a nondeterminstic finite automaton such that the reachability graph of the identified net is isomorphic to the given automaton, meaning that the Petri net models exactly the same dynamic system as the automaton. The identified net necessarily satisfies the specified structural requirements, such as the numbers of places and transitions, absence of self-loops, the exact structure of a part of the net, and so on. Since label Petri nets and nondeterminstic finite automata are generalizations of Petri nets and deterministic finite automata, respectively, the proposed approach can identify a larger spectrum of Petri nets and effectively handle the nondeterminstic cases in the given automaton. Four kinds of conditions are first extracted from the given automaton, namely deterministic enabling conditions, nondeterministic enabling conditions (i.e., multiple transitions with the same label are enabled simultaneously at a marking), transition disabling conditions, and marking inequality conditions. Then, an integer linear programming problem is formulated by characterizing these four kinds of conditions using integer linear constraints. A labeled Petri net satisfying the structural requirements is obtained by solving the integer linear programming problem. We also present two examples to show the possible applications of the proposed identification approach.

Performing Regular Operations with 1-Limited Automata

The descriptional complexity of basic operations on regular languages using 1-limited automata, a restricted version of one-tape Turing machines, is investigated. When simulating operations on deterministic finite automata with deterministic 1-limited automata, the sizes of the resulting devices are polynomial in the sizes of the simulated machines. The situation is different when the operations are applied to deterministic 1-limited automata: while for boolean operations the simulations remain polynomial, for product, star, and reversal they cost exponential in size. The costs for product and star do not reduce if the given machines are sweeping two-way deterministic finite automata. These bounds are tight.

Development of fuzzy search method for creating an efficient information search system in text data

The object of research is the processes of effective search for information in a set of textual data. The subject of the research is the fuzzy search method, which will allow to effectively solve the problem of searching for information in a set of textual data. The paper considers the process of developing a fuzzy search method, which consists of 9 consecutive steps and is required for a quick search for matches in a large set of text data. Based on this method, it is proposed to create a fuzzy search system that will solve the problem of finding the most relevant documents from a set of such documents. The proposed fuzzy search method combines the advantages of algorithms based on deterministic finite automata and algorithms based on dynamic programming for calculating the Damerau-Levenshtein distance. Such a combination allows to implement the symbol similarity table in an optimal way. As part of the work, an approach for creating a symbol similarity table was proposed and an example of such a table was created for symbols from the English alphabet, which allows to find the degree of similarity between two symbols with constant asymptotics and to convert the current symbol into its basic counterpart. For document filtering, a metric was developed to evaluate the correspondence of text data to a search phrase, which simultaneously takes into account the number of found and not found characters and the number of found and not found words. The Damerau-Levenstein algorithm allows to find the edit distance between two words, taking into account the following types of errors: substitution, addition, deletion, and transposition of characters. The work proposed a modification of this algorithm by using a similarity table to more accurately estimate the editing distance between two words. The developed method makes it possible to create a fuzzy search system that will help find the desired results faster and increase the relevance of the obtained results by sorting them according to the values of the proposed test data similarity metric.

State complexity of binary coded regular languages

For the given non-unary input alphabet Σ, a maximal prefix code h mapping strings over Σ to binary strings, and an optimal deterministic finite automaton (DFA) A with n states recognizing a language L over Σ, we consider the problem of how many states we need for an automaton A′ that decides membership in h(L), the binary coded version of L. Namely, A′ accepts binary inputs belonging to h(L) and rejects binary inputs belonging to h(LC), where LC is the complement of L. The outcome on inputs that are not valid binary codes for any string in Σ⁎ can be arbitrary: A′ may accept, reject, or halt in a “don't care” state. We show that every optimal deterministic don't care finite automaton (dcDFA) A′ solving this promise problem uses at most (‖Σ‖−1)⋅n states but at least n states. In addition, we have established a kind of pseudo-isomorphism between such DFAs and dcDFAs. We also show that, for each non-unary input alphabet Σ, there exists a maximal binary prefix code h such that, for each n≥2 and for each N in range from n to (‖Σ‖−1)⋅n, there exists a language L over Σ such that the optimal DFA recognizing L uses exactly n states and every optimal dcDFA for solving the above promise problem uses exactly N states. Thus, we have the complete state hierarchy for deciding membership in the binary coded version of L, with no magic numbers in between the lower and upper bounds.

Predictive Monitoring against Pattern Regular Languages

While current bug detection techniques for concurrent software focus on unearthing low-level issues such as data races or deadlocks, they often fall short of discovering more intricate temporal behaviours that can arise even in the absence of such low-level issues. In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications such as LTL. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency — violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software in conjunction with the analysis. Towards this, we study the problem of predictive runtime monitoring , inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution σ, if it can be soundly reordered to expose violations of a specification. In general, this problem may become easily intractable when either the specifications or the notion of reorderings used is complex. In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence , where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that, even in this simplistic setting, the problem of predictive monitoring admits a super-linear lower bound of O ( n α ), where n is the number of events in the execution, and α is a parameter describing the degree of commutativity, and typically corresponds to the number of threads in the execution. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable, unlike in the non-predictive setting where the problem can be checked using a deterministic finite automaton (and thus, a constant-space streaming linear-time algorithm). Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages ). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses underlying many concurrency bug detection approaches such as the “small bug depth” hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm. We implement and evaluate our algorithm PatternTrack on benchmarks from the literature and show that it is effective in monitoring large-scale applications.

On Learning Polynomial Recursive Programs

We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin's MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.