Acyclic Deterministic Finite Automata Research Articles

Efficient Construction of the Equation Automaton

This paper describes a fast algorithm for constructing directly the equation automaton from the well-known Thompson automaton associated with a regular expression. Allauzen and Mohri have presented a unified construction of small automata and gave a construction of the equation automaton with time and space complexity in O(mlogm+m2), where m denotes the number of Thompson automaton transitions. It is based on two classical automata operations, namely epsilon-removal and Hopcroft’s algorithm for deterministic Finite Automata (DFA) minimization. Using the notion of c-continuation, Ziadi et al. presented a fast computation of the equation automaton in O(m2) time complexity. In this paper, we design an output-sensitive algorithm combining advantages of the previous algorithms and show that its computational complexity can be reduced to O(m×|Q≡e|), where |Q≡e| denotes the number of states of the equation automaton, by an epsilon-removal and Bubenzer minimization algorithm of an Acyclic Deterministic Finite Automata (ADFA).

On the structure of compacted subword graphs of Thue–Morse words and their applications

We investigate how syntactic properties of Thue–Morse words are related to special type of automata/graphs. The directed acyclic subword graph (dawg, in short) is a useful deterministic automaton accepting all suffixes of the word. Its compacted version (resulted by compressing chains of states) is denoted by cdawg. The cdawgs of Thue–Morse words have regular and very simple structure, in particular they offer a powerful (exponential) compression of the set of all subwords in case of finite Thue–Morse words. Using the special structure of cdawgs we present several unknown properties of Thue–Morse words as well as new (graph-based) proofs of some well-known properties. In particular we show a simple algorithm that checks, for a given string w, if w is a subword of a Thue–Morse word and computes its number of occurrences in n-th Thue–Morse word in O(|w|+logn) time and O(1) space. Additionally, a slight modification of the compact dawg of the infinite Thue–Morse word yields an infinite graph with 2-counting property.

Position heaps: A simple and dynamic text indexing data structure

We address the problem of finding the locations of all instances of a string P in a text T, where preprocessing of T is allowed in order to facilitate the queries. Previous data structures for this problem include the suffix tree, the suffix array, and the compact DAWG. We modify a data structure called a sequence tree, which was proposed by Coffman and Eve (1970) [3] for hashing, and adapt it to the new problem. We can then produce a list of k occurrences of any string P in T in O ( ‖ P ‖ + k ) time. Because of properties shared by suffixes of a text that are not shared by arbitrary hash keys, we can build the structure in O ( ‖ T ‖ ) time, which is much faster than Coffman and Eve's algorithm. These bounds are as good as those for the suffix tree, suffix array, and the compact DAWG. The advantages are the elementary nature of some of the algorithms for constructing and using the data structure and the asymptotic bounds we can give for updating the data structure when the text is edited.

The structure of subword graphs and suffix trees of Fibonacci words

We use automata-theoretic approach to analyze properties of Fibonacci words. The directed acyclic subword graph (dawg) is a useful deterministic automaton accepting all suffixes of the word. We show that dawg's of Fibonacci words have particularly simple structure. Our main result is a unifying framework for a large collection of relatively simple properties of Fibonacci words. The simple structure of dawgs of Fibonacci words gives in many cases simplified alternative proofs and new interpretation of several well-known properties of Fibonacci words. In particular, the structure of lengths of paths corresponds to a number-theoretic characterization of occurrences of any subword. Using the structural properties of dawg's it can be easily shown that for a string w we can check if w is a subword of a Fibonacci word in time O ( | w | ) and O ( 1 ) space. Compact dawg's of Fibonacci words show a very regular structure of their suffix trees and show how the suffix tree for the Fibonacci word grows (extending the leaves in a very simple way) into the suffix tree for the next Fibonacci word.

How to squeeze a lexicon

AbstractMinimal acyclic deterministic finite automata (ADFAs) can be used as a compact representation of finite string sets with fast access time. Creating them with traditional algorithms of DFA minimization is resource greedy when a large collection of strings is involved. This paper aims to popularize an efficient but little‐known algorithm for creating minimal ADFAs recognizing a finite language, invented independently by several authors. The algorithm is presented for three variants of ADFAs, its minor improvements are discussed, and minimal ADFAs are compared to competitive data structures. Copyright © 2001 John Wiley & Sons, Ltd.

Compact Morphic Directed Acyclic Word Graphs

isomorphism h : � ∗ → (σ q ) ∗ , with parameter q, the string t can be transformed into h(t) ,t he factors of which are represented by another DAWG, called the morphic DAWG, over a different alphabet σ . Depending on h, t has many morphic DAWGs, which exhibit time–space trade-off compared with the original DAWG. The bounds for storage reduction and time–space efficiency between DAWG and its morphic DAWGs implemented as tables are derived, as well as for their optimal points. Likewise, the storage increase, comparing the morphic DAWG implemented as tables and DAWGs implemented using bucket arrays, are also derived. The bounds of storage increase have global minimum when |σ |= 3. Experiments show that round-off errors degrade storage reduction and time–space efficiency, so that q should be well chosen (i.e. |σ | q =| � |). The compact morphic DAWG was found to be more space efficient than both the corresponding morphic DAWG and the compact DAWG. The compact morphic DAWGs over the binary alphabet require the least storage but the access speed is slower than those over the ternary alphabet. The space demand of compact morphic DAWGs is of similar order (within a factor of 3.3) of the bucket-array implementation of DAWGs.