Finite Automata with Generalized Acceptance Criteria

We define the counting classes NC/sup 1/, GapNC/sup 1/ PNC/sup 1/ and C/sub =/NC/sup 1/. We prove that Boolean circuits, algebraic circuits, programs over nondeterministic finite automata, and programs over constant integer matrices yield equivalent definitions of the latter three classes. We investigate closure properties. We observe that NC/sup 1//spl sube/L and that C/sub =/NC/sup 1//spl sube/L. Then we exploit our finite automaton model and extend the padding techniques used to investigate leaf languages. Finally, we draw some consequences from the resulting body of leaf language characterizations of complexity classes, including the unconditional separation of ACC/sup 0/ from MOD-PH as well as that of TC/sup 0/ from the counting hierarchy. Moreover we obtain that dlogtime-uniformity and logspace-uniformity for AC/sup 0/ coincide if and only if the polynomial time hierarchy equals PSPACE.

A great number of complexity classes between P and PSPACE can be defined via leaf languages for computation trees of nondeterministic polynomial-time machines. Jenner, McKenzie, and Therien (Proceedings of the 9th Conference on Structure in Complexity Theory, 1994) raised the issue of whether considering balanced or unbalanced trees makes any difference. For a number of leaf-language classes, coincidence of both models was shown, but for the very prominent example of leaf-language classes from the alternating logarithmic-time hierarchy the question was left open. It was only proved that in the balanced case these classes exactly characterize the classes from the polynomial-time hierarchy. Here, we show that balanced trees apparently make a difference: In the unbalanced case, a class from the logarithmic-time hierarchy characterizes the corresponding class from the polynomial-time hierarchy with a PP-oracle. Along the way, we get an interesting normal form for PP computations.

Non-cancellative Boolean circuits: A generalization of monotone boolean circuits

The idea of a finite automaton walking in a labyrinth goes back to Shannon /I/. In the last years this problem has been further investigated by D~pp /2/, M~ller /3/ and Budach /4/. DSpp posed the following question: Does there exist a finite initial automaton that finds a way out of every finite plane open labyrinth from any initial position and finally moves arbitrarily far away ? MGller and Budach gave negative answers to this question, where Budach used DSpp's original definitions, while MGller treated a graph-theoretical variant of D~pp's formulation. It is the aim of this note to show how some quite natural extensions of the computational power of the automaton (called mouse by Shannon) will affect the answer to this question. We allow the mouse to be either a finite automaton, a pushdown transducer, a linear bounded automaton, or a Turing machine. In the first to cases the answer to DSpp's question is negative, while an algorithmic solution for linear bounded automata exists, such that every open labyrinth may be mastered by such mice independent from the starting point. The negative answer in the case of pushdown transducers depends on the fact that there are labyrinths where pushdown transducers have the same computational power as finite automata (which may not master these labyrinths).

Chapter 1 - Formal Requirements and Finite Automata Overview

Symbolic Model Checking for Real-Time Systems

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.

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.

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.

This paper explores the language classes that arise with respect to the head count of a finite ultrametric automaton. First we prove that in the one-way setting there is a language that can be recognized by a one-head ultrametric finite automaton and cannot be recognized by any k-head non-deterministic finite automaton. Then we prove that in the two-way setting the class of languages recognized by ultrametric finite k-head automata is a proper subclass of the class of languages recognized by (k + 1)-head automata. Ultrametric finite automata are similar to probabilistic and quantum automata and have only just recently been introduced by Freivalds. We introduce ultrametric Turing machines and ultrametric multi-register machines to assist in proving the results.

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).

Generalized acceptance, succinctness and supernondeterministic finite automata

A language is called (m,n)-verbose if there exists a Turing machine that enumerates for any n words at most m possibilities for their characteristic string. This notion is compared with (m,n)-fa-verboseness, where instead of a Turing machine a finite automaton is used. By use of a new diagonalisation method, where finite automata trick Turing machines, it is shown that all (m,n)-verbose languages are (h,k)-verbose iff all (m,n)-fa-verbose languages are (h,k)-fa-verbose. In other words, Turing machines and finite automata behave exactly the same way with respect to inclusion of verboseness classes. This identical behaviour implies that the nonspeedup theorem also holds for finite automata. As an application of the theoretical framework, a lower bound is derived on the number of bits that need to be communicated to finite automata protocol checkers for nonregular protocols.

We compare the measures of sequential time modelled using Turing machines and of parallel size modelled using Boolean circuits. This is done by constructing oracles which show certain relationships between complexity classes. An oracle B is shown for which Δ2P,B has 2n+o(n) size circuits relative to B. On the other hand, we give a C so that PC does not, for any k, have size nk circuits relative to C and yet NPC ≡ coNPC. These techniques can be combined to yield a D relative to which PD has 2n + o(n) size circuits but RD does not have size nk circuits for any k.