Deterministic Finite Automata Research Articles

DESIGN AND IMPLEMENTATION OF A LANGUAGE SCANNER GENERATOR (KnitAutoGen)

The need for fast, efficient and simple scanner generator that has the primary responsibility to perform efficiently gave rise to this paper. This is due to the fact that, on daily basis new technologies arise which brings a great improvement on the design of computer architecture. However, attention was given to speed, run time and resource availability of the design machine to be used since lexical analysis has an impact on how the compiler works. This paper seeks to develop a lexical analyzer (scanner generator) automatically by specifying the lexemes patterns to a lexical analyzer generator and compiling those patterns into a code that functions as a lexical analyzer. The scanner accepts characters as input and breaks them down to produce tokens by grouping the characters and not deviating from specifications. The project employs one of the different methods of lexical analyzer generator to perform pattern-matching on text using regular expression over a global character set. The paper shows how input is matched and specifies what to do when a pattern is matched. This was achieved with the use of regular expressions (RE) which were converted to non-deterministic finite automata (NFA) or deterministic finite automata (DFA). The regular expression and the regular grammar were thus joined together mathematically. Various results are presented and further work on micro compilers was proposed. Keyword: Scanner generator, Regular expression, KnitAutoGen, DFA, NFA. DOI : 10.7176/CTI/8-02

Finite-state independence and normal sequences

We consider the previously defined notion of finite-state independence and we focus specifically on normal words. We characterize finite-state independence of normal words in three different ways, using three different kinds of asynchronous deterministic finite automata with two input tapes containing infinite words. Based on one of the characterizations we give an algorithm to construct a pair of finite-state independent normal words.

Theory of tailor automata

In the paper, a fragment of the new theory of tailor automata is presented, within which a deterministic finite automaton was defined. The proposed automaton provides a theoretical model of an informally characterized biomolecular automaton. The idea of working of which is founded on the concept of alternating cut of some double-stranded fragments of DNA, with the use of a restriction enzyme and ligations of some double-stranded fragments of DNA, with the use of the ligase enzyme.

AUTO STEMMING OF AZERBAIJANI LANGUAGE

One of important features in natural language processing is to find the root of a word. Stemming means to remove prefixes, suffixes, and infixes for finding the root of the word. Its aims are about to information retrieval, exploring text, machine for translation, and word look up based on its root. Stemming increases document retrieval by 10-50% in most of international languages, it also compresses the size of web-based table indexes documents up to 50%. In this paper, by analyzing stemming approaches, using structural methods, and deterministic finite automaton machine, applying 274 existing prefixes in language (linkage), a stemming system for Azerbaijani language is generated. Experimental result demonstrates that the proposed algorithm performs more than 97% accuracy.

Descriptional Complexity of the Forever Operator

We examine the descriptional complexity of the forever operator, which assigns the language [Formula: see text] to a regular language [Formula: see text], and we investigate the trade-offs between various models of finite automata. We consider complete and partial deterministic finite automata, nondeterministic finite automata with single or multiple initial states, alternating, and Boolean finite automata. We assume that the argument and the result of this operation are accepted by automata belonging to one of these six models. We investigate all possible trade-offs and provide a tight upper bound for 32 of 36 of them. The most interesting result is the trade-off from nondeterministic to deterministic automata given by the Dedekind number [Formula: see text]. We also prove that the nondeterministic state complexity of [Formula: see text] is [Formula: see text] which solves an open problem stated by Birget [The state complexity of [Formula: see text] and its connection with temporal logic, Inform. Process. Lett. 58 (1996) 185–188].

State complexity of pattern matching in regular languages

In a simple pattern matching problem one has a pattern w and a text t, which are words over a finite alphabet Σ. One may ask whether w occurs in t, and if so, where? More generally, we may have a set P of patterns and a set T of texts, where P and T are regular languages. We are interested whether any word of T begins with a word of P, ends with a word of P, has a word of P as a factor, or has a word of P as a subsequence. Thus we are interested in the languages (PΣ⁎)∩T, (Σ⁎P)∩T, (Σ⁎PΣ⁎)∩T, and ▪, where ▪ is the shuffle operation. The state complexity κ(L) of a regular language L is the number of states in the minimal deterministic finite automaton recognizing L. We derive the following upper bounds on the state complexities of our pattern-matching languages, where κ(P)⩽m, and κ(T)⩽n: κ((PΣ⁎)∩T)⩽mn; κ((Σ⁎P)∩T)⩽2m−1n; κ((Σ⁎PΣ⁎)∩T)⩽(2m−2+1)n; and ▪. We prove that these bounds are tight, and that to meet them, the alphabet must have at least two letters in the first three cases, and at least m−1 letters in the last case.

A Quick Algorithm for Binary Discernibility Matrix Simplification using Deterministic Finite Automata

The binary discernibility matrix, originally introduced by Felix and Ushio, is a binary matrix representation for storing discernible attributes that can distinguish different objects in decision systems. It is an effective approach for feature selection, knowledge representation and uncertainty reasoning. An original binary discernibility matrix usually contains redundant objects and attributes. These redundant objects and attributes may deteriorate the performance of feature selection and knowledge acquisition. To overcome this shortcoming, row relations and column relations in a binary discernibility matrix are defined in this paper. To compare the relationships of different rows (columns) quickly, we construct deterministic finite automata for a binary discernibility matrix. On this basis, a quick algorithm for binary discernibility matrix simplification using deterministic finite automata (BDMSDFA) is proposed. We make a comparison of BDMR (an algorithm of binary discernibility matrix reduction), IBDMR (an improved algorithm of binary discernibility matrix reduction) and BDMSDFA. Finally, theoretical analyses and experimental results indicate that the algorithm of BDMSDFA is effective and efficient.

New Lightweight Architectures for Secure FSM Design to Thwart Fault Injection and Trojan Attacks

Finite state machine (FSM) is a critical part in digital processing devices used in Internet of Things (IoT) applications as it controls complete functionality of the device. The synthesis tool implements deterministic FSM by adding extra don’t care states/transitions during optimization. This additional insertion makes the FSM vulnerable to setup-time violation based fault injection (STVFI) and hardware Trojan attacks. The existing techniques are inefficient to completely mitigate these vulnerabilities and exhibit significant design overhead. Therefore, this paper presents a novel lightweight secure machine design technique that completely mitigates the vulnerabilities with minimum overhead. The paper first proposes a new metric to identify all types of vulnerable transitions (VTs) followed by a trustworthy FSM design algorithm and efficient vulnerability mitigation architecture (EVMA). Though our EVMA completely alleviates the vulnerabilities to STVFI and Trojan attacks, it slightly increases the overhead due to additional multiplexers. Hence, we also propose new secure FSM design algorithm and two new lightweight vulnerability mitigation architectures (LVMA-I and LIVMA-II) that control the FFs using existing clear and/or preset pins instead of multiplexers. The experimental results on AES and RSA encryption modules show that the proposed technique detects 100% VTs. Further, ASIC and FPGA implementation of the proposed LIVMA-II using Cadence RTL and Xilinx Vivado presents on an average 40%, 59.6%, and 51.1% reduced area, power and delay respectively compared to the well-known technique. Due to negligible design overhead, our technique is best suitable for designing secure controller of portable IoT devices.

Exploring efficient grouping algorithms in regular expression matching.

BackgroundRegular expression matching (REM) is widely employed as the major tool for deep packet inspection (DPI) applications. For automatic processing, the regular expression patterns need to be converted to a deterministic finite automata (DFA). However, with the ever-increasing scale and complexity of pattern sets, state explosion problem has brought a great challenge to the DFA based regular expression matching. Rule grouping is a direct method to solve the state explosion problem. The original rule set is divided into multiple disjoint groups, and each group is compiled to a separate DFA, thus to significantly restrain the severe state explosion problem when compiling all the rules to a single DFA.ObjectiveFor practical implementation, the total number of DFA states should be as few as possible, thus the data structures of these DFAs can be deployed on fast on-chip memories for rapid access. In addition, to support fast pattern update in some applications, the time cost for grouping should be as small as possible. In this study, we aimed to propose an efficient grouping method, which generates as few states as possible with as little time overhead as possible.MethodsWhen compiling multiple patterns into a single DFA, the number of DFA states is usually greater than the total number of states when compiling each pattern to a separate DFA. This is mainly caused by the semantic overlaps among different rules. By quantifying the interaction values for each pair of rules, the rule grouping problem can be reduced to the maximum k-cut graph partitioning problem. Then, we propose a heuristic algorithm called the one-step greedy (OSG) algorithm to solve this NP-hard problem. What’s more, a subroutine named the heuristic initialization (HI) algorithm is devised to further optimize the grouping algorithms.ResultsWe employed three practical rule sets for the experimental evaluation. Results show that the OSG algorithm outperforms the state-of-the-art grouping solutions regarding both the total number of DFA states and time cost for grouping. The HI subroutine also demonstrates its significant optimization effect on the grouping algorithms.ConclusionsThe DFA state explosion problem has became the most challenging issue in the regular expression matching applications. Rule grouping is a practical direction by dividing the original rule sets into multiple disjoint groups. In this paper, we investigate the current grouping solutions, and propose a compact and efficient grouping algorithm. Experiments conducted on practical rule sets demonstrate the superiority of our proposal.

Bitmaps & Bitmasks: Efficient Tools to Compress Deterministic Automata

Accelerating the signature matching function is essential to perform Deep Packet Inspection (DPI) at line rates. The conversion of the signatures into the Deterministic Finite Automaton (DFA) enables performance of this function at linear time. However, since the DFA is extremely storage inefficient, it is compressed before being stored in the memory. Although state-of-the-art bitmap-based compression algorithms can perform line rate signature matching, they only achieve transition compression of ~90-95%. Addressing the storage inefficiency, two bitmap-based transition compression algorithms were proposed by Subramanian et al. in 2016 to achieve transition compression of over 98%. A theoretical relationship is established in this article between the achievable signature matching throughput and the number of pipeline stages required to perform the decompression through the hardware accelerator based on the proposed techniques. Additional optimizations are proposed and evaluated to improve the per-stream signature matching throughput through the proposed decompression engines. The experimental evaluation of the optimizations shows that the per-stream signature matching throughput can be improved by a factor of 1.2–1.4x. A software model of the proposed decompression engines was designed and evaluated across a multitude of payload byte streams to verify the functional correctness of the proposed compression methods.

Bitmaps & Bitmasks: Efficient Tools to Compress Deterministic Automata

Accelerating the signature matching function is essential to perform Deep Packet Inspection (DPI) at line rates. The conversion of the signatures into the Deterministic Finite Automaton (DFA) enables performance of this function at linear time. However, since the DFA is extremely storage inefficient, it is compressed before being stored in the memory. Although state-of-the-art bitmap-based compression algorithms can perform line rate signature matching, they only achieve transition compression of ~90-95%. Addressing the storage inefficiency, two bitmap-based transition compression algorithms were proposed by Subramanian et al. in 2016 to achieve transition compression of over 98%. A theoretical relationship is established in this article between the achievable signature matching throughput and the number of pipeline stages required to perform the decompression through the hardware accelerator based on the proposed techniques. Additional optimizations are proposed and evaluated to improve the per-stream signature matching throughput through the proposed decompression engines. The experimental evaluation of the optimizations shows that the per-stream signature matching throughput can be improved by a factor of 1.2–1.4x. A software model of the proposed decompression engines was designed and evaluated across a multitude of payload byte streams to verify the functional correctness of the proposed compression methods.

A matrix-based approach to verifying stability and synthesizing optimal stabilizing controllers for finite-state automata

In this paper, we develop a matrix-based methodology to investigate the problems of stability and stabilizability for a deterministic finite automaton (DFA) in the framework of the semi-tensor product (STP) of matrices. First, we discuss the equilibrium point stability (resp., set stability) of a DFA, i.e., verifying whether or not all state trajectories starting from a subset of states converge to a specified equilibrium point (resp., subset of states). The necessary and sufficient conditions for verifying both stabilities are given, respectively. Second, equilibrium point stabilizability (resp., set stabilizability) of a DFA is investigated as verifying the issue of whether or not a DFA can be globally or locally stabilized to a specified equilibrium point (resp., subset of states) by a permissible state-feedback controller. Based on the pre-reachability set and invariant-subset defined in this paper, the matrix-based criteria for verifying equilibrium point stabilizability and set stabilizability are derived, respectively. Furthermore, for each type of stabilizability, all permissible state-feedback controllers for the case of minimal length state trajectories, called optimal state-feedback controllers, are characterized by using the proposed polynomial algorithms. Finally, two examples are presented to illustrate the effectiveness of the theoretical results.

Determinization of fuzzy automata by factorizations of fuzzy states and right invariant fuzzy quasi-orders

In this paper we provide improvements of determinization methods, based on factorization of fuzzy states, for fuzzy finite automata that accept fuzzy languages of infinite range. The improvements are based on the usage of the fuzzy relational calculus, namely, on the usage of the right invariant fuzzy quasi-orders. Our algorithms perform better in the sense that they produce smaller automata, while require the same computation time. In addition, they can produce finite deterministic automata in cases when previous algorithms result in infinite deterministic automata. We show that the weak representable-cycles property is necessary and sufficient condition for determinization of a fuzzy automaton via a maximal factorization of fuzzy states. This condition is more general than the representable-cycles property previously determined as the necessary and sufficient condition for determinization of a fuzzy automaton via a maximal factorization of fuzzy states.

Conditions for Minimal Fuzzy Deterministic Finite Automata via Brzozowski's Procedure

This paper deals with the application of Brzozowski's minimization procedure to fuzzy finite automata with truth-values in a complete residuated (zero-divisor-free) lattice. For a given fuzzy finite automaton $\mathcal{A}$ , the procedure computes the automaton $d(r(d(r(\mathcal{A})))$ , where $d(\mathcal{A})$ is a (fuzzy) determinization of $\mathcal{A}$ , and $r(\mathcal{A})$ is the reverse automaton of $\mathcal{A}$ . It is observed that the size of the resulting automaton is strongly dependent on the determinization method used in the procedure. Consequently, this paper studies necessary and sufficient conditions for obtaining minimal fuzzy deterministic finite automata via Brzozowski's procedure. The study is accomplished for determinization methods based on a generalized notion of accessible fuzzy subset construction. The obtained conditions determine that Brzozowski's procedure returns a minimal fuzzy deterministic finite automaton when the determinization method does not produce proportional fuzzy states. This is the reason to obtain minimal fuzzy deterministic finite automata using Brzozowski's procedure for fuzzy finite automata with truth-values in the product-structure when the determinization method is the method based on factorization of fuzzy states.

Finite LTL Synthesis as Planning

LTL synthesis is the task of generating a strategy that satisfies a Linear Temporal Logic (LTL) specification interpreted over infinite traces. In this paper we examine the problem of LTLf synthesis, a variant of LTL synthesis where the specification of the behaviour of the strategy we generate is interpreted over finite traces -- similar to the assumption we make in many planning problems, and important for the synthesis of business processes and other system interactions of finite duration. Existing approaches to LTLf synthesis transform LTLf into deterministic finite-state automata (DFA) and reduce the synthesis problem to a DFA game. Unfortunately, the DFA transformation is worst-case double-exponential in the size of the formula, presenting a computational bottleneck. In contrast, our approach exploits non-deterministic automata, and we reduce the synthesis problem to a non-deterministic planning problem. We leverage our approach not only for strategy generation but also to generate certificates of unrealizability -- the first such method for LTLf. We employ a battery of techniques that exploit the structure of the LTLf specification to improve the efficiency of our transformation to automata. We combine these techniques with lazy determinization of automata and on-the-fly state abstraction. We illustrate the effectiveness of our approach on a set of established LTL synthesis benchmarks adapted to finite LTL.

Application of Diagrams of Deterministic Finite Automata for a Formal Description of Operating Modes of Electrical Apparatuses

This article suggests ways to describe the behavior and interaction of electrical apparatuses. Using the example of a modern modular circuit breaker, the possibility and necessity of the use of formal description of electrical-apparatus operation modes by means of deterministic finite automata is shown. The article demonstrates the solution the problem of the functional identification of this apparatus along with the impossibility of verifying the technical solutions for the interacting apparatus complexes without an available formal description of all devices that are parts of the system. It is shown that the application of the theory of deterministic finite automata for the formal presentation of electrical apparatuses as a mathematical object allows one to proceed to the simulation modeling of operation of both individual devices and a complex of interacting apparatuses.

Intelligent and efficient grouping algorithms for large-scale regular expressions

Regular expressions are widely used in various applications. Due to its low time complexity and stable performance, Deterministic Finite Automaton (DFA) has become the first choice to perform fast regular expression matching. Unfortunately, compiling a large set of regular expressions into one DFA often leads to the well-known state explosion problem, and consequently requires huge memory consumption. Regular expression grouping is a practical approach to mitigate this problem. However, existing grouping algorithms are either brute-force or locally optimal and thus not efficient for large-scale regular expressions. In this paper, we propose two grouping algorithms, namely Reevo and Reant, to solve this problem intelligently and efficiently. In addition, two optimization methods are presented to accelerate the convergence speed and reduce the running time of proposed algorithms. Experimental results on large-scale rulesets from real world show that our algorithms achieve around 25% to 45% improvement compared to previous regular expression grouping algorithms.

Complexity of deciding detectability in discrete event systems

Detectability of discrete event systems (DESs) is a question whether the current and subsequent states can be determined based on observations. Shu and Lin designed a polynomial-time algorithm to check strong (periodic) detectability and an exponential-time (polynomial-space) algorithm to check weak (periodic) detectability. Zhang showed that checking weak (periodic) detectability is PSpace-complete. This intractable complexity opens a question whether there are structurally simpler DESs for which the problem is tractable. In this paper, we show that it is not the case by considering DESs represented as deterministic finite automata without non-trivial cycles, which are structurally the simplest deadlock-free DESs. We show that even for such very simple DESs, checking weak (periodic) detectability remains intractable. On the contrary, we show that strong (periodic) detectability of DESs can be efficiently verified on a parallel computer.

Primitivity, Uniform Minimality, and State Complexity of Boolean Operations

A minimal deterministic finite automaton (DFA) is uniformly minimal if it always remains minimal when the final state set is replaced by a non-empty proper subset of the state set. We prove that a permutation DFA is uniformly minimal if and only if its transition monoid is a primitive group. We use this to study boolean operations on group languages, which are recognized by direct products of permutation DFAs. A direct product cannot be uniformly minimal, except in the trivial case where one of the DFAs in the product is a one-state DFA. However, non-trivial direct products can satisfy a weaker condition we call uniform boolean minimality, where only final state sets used to recognize boolean operations are considered. We give sufficient conditions for a direct product of two DFAs to be uniformly boolean minimal, which in turn gives sufficient conditions for pairs of group languages to have maximal state complexity under all binary boolean operations ("maximal boolean complexity"). In the case of permutation DFAs with one final state, we give necessary and sufficient conditions for pairs of group languages to have maximal boolean complexity. Our results demonstrate a connection between primitive groups and automata with strong minimality properties.

Domination problems with no conflicts

Domination problems have been studied in graph theory for decades. In most of them, it is NP-complete to find an optimal solution, while it is easy (and even trivial in some cases) to find a solution in polynomial time, regardless of its size.In recent works, authors added conflicts to classical discrete optimization problems. In this paper, a conflict is a pair of vertices that cannot be both in a solution. Set of conflicts can be viewed as edges of a so called conflict graph. An instance is then a support graph and a conflict graph. With these new constraints, the existence of a solution (dominating set or independent dominating set) with no conflicts is no more guaranteed. We explore this subject and we prove that it is NP-complete to decide the existence of a solution even in very restricted classes of graphs and conflicts (sparse or dense). We also propose polynomial algorithms for some sub-cases, using deterministic finite automata.