Nondeterministic Finite Automata

2020

We revisit the complexity of procedures on SFAs (such as intersection, emptiness, etc.) and analyze them according to the measures we find suitable for symbolic automata: the number of states (n), the maximal number of transitions exiting a state (m) and the size of the most complex transition predicate (l). We pay attention to the special forms of SFAs: normalized SFAs and neat SFAs, as well as to SFAs over a monotonic effective Boolean algebra.

Computing Research Repository, 2009

We give an unique string representation, up to isomorphism, for initially connected deterministic finite automata (ICDFA's) with n states over an alphabet of k symbols. We show how to generate all these strings for each n and k, and how its enumeration provides an alternative way to obtain the exact number of ICDFA's. * Work partially funded by Fundação para a Ciência e Tecnologia (FCT) and Program POSI.

In this paper we are implementing the regular expression matching is done using finite state Aleshin type automata, including non-deterministic finite state aleshin type automata (NAAs) and deterministic finite automata (DAAs). Storage space of automata is jointly determined by the number of states and transitions between states. A key issue is that the size of the automaton obtained from a regular expression is large, where size is defined as the number of states and transition arcs between states. The size of an automaton is crucial for the efficiency of the algorithms using three pattern matching based on regular expressions, size directly affects both time and space efficiency. NAAs and DAAs have their own advantages and disadvantages in regular expression matching. Keywords: deterministic finite state Aleshin type automata, non-deterministic finite state aleshin type automata (NAAs) and partial derivative automata I.INTRODUCTION NFAs can provide an exponentially more succinct description than DFAs but equivalence, inclusion, and universality are computationally hard for NFAs, while many of these problems can be solved in polynomial time for DFAs. The processing complexity for each character in the input is O (1) in a DFA, but O (n 2) for an NFA if all n states are active at the same time. The key feature of a DFA is that there is only one active state at any time; but converting an NFA into a DFA may generate O (Σ n) states. The size of a DFA, obtained fro m a regular expression, can increase exponentially; the DFA of a regular expression with thousands of patterns yields tens of thousands of states, which means memory consumption of thousands of megabytes. Another problem is that a minimal NFA is hard to co mpute [6]. How to use the matching e fficiency of a DFA and the storage efficiency of an NFA to realize matching is always a pursued goal in the field of regular exp ression matching. The regular expression is an important notation for specific patterns. Owing to its expressive power and flexib ility in describing useful patterns [1], regular expression matching technology based on finite automat a is widely used in networks and information processing, including applications for network real-t ime processing, protocol analysis, intrusion detection systems, intrusion prevention systems, deep packet inspection systems, and virus detection systems like Snort [2], Linu x L7-filter [3], and Bro [4]. Regular expressions are replacing explicit string patterns as the method of choice for describing patterns. However, with the increasing scale and number of regular exp ressions in a practical system, it is challenging to achieve good performance fo r pattern matching based on regular expressions. For example, the number of signatures in Snort has grown from 3166 in 2003 to 15,047 in 2009 and the pattern matching routines in Snort account for up to 70% of the total execution time with 80% of the instructions executed on real traces [5]. II. REGULAR EXPRESSION The term alphabet denotes any finite set of symbols. A string over an alphabet is a finite sequence of symbols drawn fro m that alphabet with the term word often used as a synonym for the term string. Let Σ be an alphabet and Σ * be the set of all words over Σ , i.e., Σ * denotes the set of all finite strings of symbols in Σ. If Σ is an alphabet, then any subset of Σ * is a language over Σ. The length of a word w ∈ Σ * , usually written as |w |, is the number of occurrences of symbols in w , with ε denoting the empty word whose length is 0. ∅ is the empty set, a ∈ Σ is an input symbol, and r and s are regular expressions. A regular expression describes a set of strings witho ut enumerating them exp licit ly. A regular expression over Σ , which can be recursively de fined, is defined as follo ws: (1)∅ and ε are regular expressions, denoting ∅ and {ε}, respectively. (2)If a is a symbol in Σ , then a is a regular expression that denotes {a}. (3)Suppose r and s are regular expressions denoting the languages L (r) and L (s). Then, (r) + (s), (r) · (s), r * , and (r) are also regular exp ressions denoting L (r) ∪ L (s), L(r)L (s), (L (r)) * , and L (r), respectively. (4)All regular exp ressions can be obtained by applying rules (1), (2), and (3) a fin ite number of t imes.

Developments in Language Theory, 2016

A nondeterministic finite automaton is unambiguous if it has at most one accepting computation on every input string. We investigate the complexity of basic regular operations on languages represented by unambiguous finite automata. We get tight upper bounds for intersection (mn), left and right quotients (2 n − 1), positive closure (3/4 • 2 n − 1), star (3/4 • 2 n), shuffle (2 mn − 1), and concatenation (3/4 • 2 m+n − 1). To prove tightness, we use a binary alphabet for intersection and left and right quotients, a ternary alphabet for star and positive closure, a fiveletter alphabet for shuffle, and a seven-letter alphabet for concatenation. We also get some partial results for union and complementation.

Lecture Notes in Computer Science, 2016

We survey recent results on the descriptional complexity of self-verifying finite automata. In particular, we discuss the cost of simulation of self-verifying finite automata by deterministic finite automata, and the complexity of basic regular operations on languages represented by self-verifying finite automata.

2013

We define a new measure of complexity for finite strings using nondeterministic finite automata, called nondeterministic automatic complexity and denoted A N (x). In this paper we prove some basic results for A N (x), give upper and lower bounds, estimate it for some specific strings, begin to classify types of strings with small complexities, and provide A N (x) for |x| ≤ 8. iii TABLE OF CONTENTS

International Journal on Software Tools for Technology Transfer (STTT), 1999

We consider the problem of storing a set S k as a deterministic nite automaton (DFA). We s h o w that inserting a new string 2 k or deleting a string from the set S represented as a minimized DFA can be done in expected time O(kj j), while preserving the minimality of the DFA. We then discuss an application of this work to reduce the memory requirements of a model checker based on explicit state enumeration.

Computer Science–Theory and …, 2008

Lecture Notes in Computer Science, 2013

We study the computational power of P automata, variants of symport/antiport P systems which characterize string languages by applying a mapping to the sequence of multisets entering the system during computations. We consider the case when the input mapping is defined in such a way that it maps a multiset to the set of strings consisting of all permutations of its elements. We show that the computational power of this type of P automata is strictly less than so called restricted logarithmic space Turing machines, and we also exhibit a strict infinite hierarchy within the accepted language class based on the number of membranes present in the system.

Information and Computation, 2001

The study of the computational power of randomized computations is one of the central tasks of complexity theory. The main goal of this paper is the comparison of the power of Las Vegas computation and deterministic respectively nondeterministic computation. We investigate the power of Las Vegas computation for the complexity measures of one-way communication, ordered binary decision diagrams, and finite automata. (i) For the one-way communication complexity of two-party protocols we show that Las Vegas communication can save at most one half of the deterministic one-way communication complexity. We also present a language for which this gap is tight. (ii) The result (i) is applied to show an at most polynomial gap between determinism and Las Vegas for ordered binary decision diagrams. (iii) For the size (i.e., the number of states) of finite automata we show that the size of Las Vegas finite automata recognizing a language L is at least the square root of the size of the minimal deterministic finite automaton recognizing L. Using a specific language we verify the optimality of this lower bound.