Nondeterministic NC/sup 1/ computation

We examine the descriptive complexity of the combined unary operation \(\overline{\varSigma ^*\overline{L}}\) and 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 \({{\mathrm{M}}}(n-1)\). We also prove that the nondeterministic state complexity of \(\overline{\varSigma ^*\overline{L}}\) is \(2^{n-1}\) which solves an open problem stated by Birget [1996, The state complexity of \(\overline{\varSigma ^*\overline{L}}\) and its connection with temporal logic, Inform. Process. Lett. 58, 185–188].

We examine the power of nondeterministic finite automata with acceptance of an input word defined by a so called leaf language, i. e., a condition on the sequence of leaves in the automaton's computation tree. We study leaf languages either taken from one of the classes of the Chomsky hierarchy, or taken from a time- or space-bounded complexity class. We contrast the obtained results with those known for leaf languages for Turing machines and Boolean circuits.

Meyer and Fischer b][MF] proved that nondeterministic finite automata (NFA) can be exponentially more concise than deterministic finite automata (DFA) in their representations of regular languages. Several variants of that basic finite state machine model are now being used to analyze parallelism and to build real-time software systems [HL+]. Even though these variants can sometimes represent regular languages in a more concise manner than NFA, the underlying models fundamentally differ from NFA in how they operate. Degree automata [W] (DA), however, differ from NFA only in their acceptance criteria and accept only regular languages. We show here that DA are also exponentially more concise than NFA on some sequences of regular languages. We also show that the conciseness of probabilistic automata [R] with isolated cutpoints can be unbounded over DA and, concurrently, i.e., over the same sequence of languages, those DA can be exponentially more concise than NFA.

Many difficult open problems in theoretical computer science center around nondeterminism. We study the fundamental problem of converting a given deterministic finite automaton (DFA) to a minimal nondeterministic finite automaton (NFA). Despite extensive work on finite automata, this fundamental problem has remained open. Recently, in [Ji91] we studied this problem and showed that this (and related) problems are computationally hard. Here we study the restriction of this problem to the case when the input DFA is over a one-letter alphabet. Even in this restricted case the problem is computationally hard even though our evidence of hardness is different from (and is weaker than) the standard ones such as NP-hardness. Let A → B denote the problem of converting a finite automaton of type A to a minimal finite automaton of type B. Our main result is that DFA → NFA, when the input is a unary cyclic DFA (a DFA whose graph is a simple cycle), is in NP but not in P unless NP ⊑ DTIME(nO(log n)). Our work was also motivated by the problem of finding structurally simple ‘normal forms’ of NFA's over a unary alphabet. We present some normal forms for minimal NFA's over a unary alphabet and present an application to lower bounds on the size complexity of an NFA. In fact, the normal form result is used in a nontrivial manner to show the NP membership result stated above.

We examine the costs of the conversions between six automata models: deterministic finite automata, partial deterministic finite automata, nondeterministic finite automata with a unique final state and multiple final states, respectively, alternating finite automata, and Boolean finite automata. We present a tight upper bound for each conversion. All witnesses are described over a unary or binary alphabet, and we show that whenever a binary alphabet is used, it is always optimal.

A very recent paper by Caussinus, McKenzie, Therien, and Vollmer [CMTV95] shows that ACC0 is properly contained in ModPH, and TC0 is properly contained in the counting hierarchy. Thus, [CMTV95] shows that there are problems in ModPH that require superpolynomialsize uniform ACC0 circuits, and problems in the counting hierarchy that require superpolynomial-size uniform TC0 circuits. The proof in [CMTV95] uses “leaf languages” as a tool in obtaining their separations, and their proof does not immediately yield larger lower bounds for the complexity of these problems. In this paper, we give a simple direct proof of these same separations, and use it to provide “sub-subexponential” size lower bounds on the size of uniform circuits for these problems.

Regular Expressions (RegExes) are widely used in various applications to identify strings of text. Their flexibility, however, increases the complexity of the detection system and often limits the detection speed as well as the total number of RegExes that can be detected using limited resources. The two classical detection methods, Deterministic Finite Automaton (DFA) and Non-Deterministic Finite Automaton (NFA), have the potential problems of prohibitively large memory requirements and a large number of concurrent operations, respectively. Although recent schemes addressing these problems to improve DFA and NFA are promising, they are inherently limited by their scalability, since they follow the state transition model in DFA and NFA, where the state transitions occur per each character of the input. We recently proposed a scalable RegEx detection system called Lookahead Finite Automata (LaFA) to solve these problems with three novel ideas: 1. Provide specialized and optimized detection modules to increase resource utilizations. 2. Systematically reordering the RegEx detection sequence to reduce number of concurrent operations. 3. Sharing states among automata for different RegExes to reduce resource requirements. In this paper, we propose an efficient hardware architecture and prototype design implementation based on LaFA. Our proof-of-concept prototype design is built on a fraction of a single commodity Field Programmable Gate Array (FPGA) chip and can accommodate up to twenty-five thousand (25k) RegExes. Using only 7% of the logic area and 25% of the memory on a Xilinx Virtex-4 FX100, the prototype design can achieve 2-Gbps (gigabits-per-second) detection throughput with only one detection engine. We estimate that 34-Gbps detection throughput can be achieved if the entire resources of a state-of-the-art FPGA chip are used to implement multiple detection engines.

Chapter 1 - Formal Requirements and Finite Automata Overview

Generalized acceptance, succinctness and supernondeterministic finite automata

With the increasing international communications, people are eager to learn foreign languages. As an auxiliary tool, multimedia learning machine (MLM) is welcomed by foreign language learners. So, it is very necessary to design a powerful MLM efficiently. How to deal with the state transition of MLM's different states is a key issue. In this paper, we describe a solution to design a MLM based on non-deterministic finite automaton (MLM-NFA) and present in detail the state transition model, state transition diagram and the core algorithm. The finite automaton helps us distinguish clearly the relation of state transitions of MLM and the mapping between MLM states and buttons in MLM user interfaces. The MLM-NFA has many advanced functions, such as point-to-read, A-B repeating and role playing. At the end of the paper, we implement an MLM-NFA which proves that the model based on non-deterministic finite automaton principle is quite efficient in practice and makes it very simple and flexible in development.

The number of states of a deterministic finite automaton, which is equivalent to a nondeterministic finite automaton is bounded by 2n, where n is the number of states of the nondeterministic finite automaton. This bound is very pesimistic. Some subclasses of finite automata are shown, for which the complexity of determinization is far lower. On the base of pioneering idea of homogenous finite automata, two classes of finite automata are defined and the complexity of their determinization are shown. These classes are called generalized homogenous finite automata and semihomogenous finite automata.

The finite automata are mathematical models for finite state systems. More general finite automaton is the nondeterministic finite automaton (NFA) that cannot be directly used. It is usually transformed to the deterministic finite automaton (DFA) that then runs in time O(n), where n is the size of the input text. We present two main approaches to practical implementation of DFA considering CPU cache. The first approach (represented by Table Driven and Hard Coded implementations) is suitable forautomata being run very frequently, typically having cycles. The other approach is suitable for a collection of automata from which various automata are retrieved and then run. This second kind of automata are expected to be cycle-free.

It is known that a nondeterministic finite automaton (NFA) with n states and branching k can be simulated by a deterministic finite automaton with multiple initial states (MDFA) having k ·n states. We give a lower bound \(\frac{k}{1 + \log k} \cdot n\) for the size blow-up of this conversion. We consider also upper and lower bounds for the number of states an MDFA needs to simulate a given NFA of finite tree width.

Many network security applications such as Intrusion Detection System (IDS), Firewall and Data Loss Prevention System (DLPS) are based on deep packet inspection, in this packets header as well as payload of the packets are checked with predefined attack signature to identify whether it contains malicious traffic or not. To perform this checking different pattern matching methods are used by NIDS. The most popular method to implement pattern matching is to use of Finite Automata (FA). Generally, regular expressions are used to represent most of the attack signatures defined by NIDS. They are implemented using finite automata, which takes the payload of packet as input string. However, existing approaches of Finite Automata (FA), both deterministic finite automata (DFA) and non-deterministic finite automata (NFA) for pattern matching are having their own advantages and some drawbacks. The DFA based pattern matching methods are fast enough but require more memory. However, NFA based pattern matching methods are comparatively takes less memory but the speed of matching is very slow, to overcome these drawbacks of finite automata there are many approaches have been proposed. This paper discuses comparative study of some Finite Automata (FA) based techniques for pattern matching in network intrusion detection system (NIDS).

Consideration was given to accommodation to the defects in controllable systems described by the finite automaton model. Solution of this problem was related with generation of the control ensuring total decoupling from the actions caused by the defects. For determination of the control law, the existence conditions were formulated, and the design formulas were proposed.