Parallel Algorithms for Minimal Nondeterministic Finite Automata Inference

The goal of this paper is to develop the parallel algorithms that, on input of a learning sample, identify a regular language by means of a nondeterministic finite automaton (NFA). A sample is a pair of finite sets containing positive and negative examples. Given a sample, a minimal NFA that represents the target regular language is sought. We define the task of finding an NFA, which accepts all positive examples and rejects all negative ones, as a constraint satisfaction problem, and then propose the parallel algorithms to solve the problem. The results of comprehensive computational experiments on the variety of inference tasks are reported. The question of minimizing an NFA consistent with a learning sample is computationally hard.

Branching Measures and Nearly Acyclic NFAs

To get a more comprehensive understanding of the amount of branching in computations of a nondeterministic finite automaton (NFA), we introduce and study the string path width and depth path width measures. For a given NFA, the string path width on a string [Formula: see text] counts the number of all complete computations on [Formula: see text], and the depth path width on an integer [Formula: see text] counts the number of complete computations on all strings of length [Formula: see text]. We give an algorithm to decide the finiteness of the depth path width of an NFA. Deciding finiteness of string path width can be reduced to the corresponding question on ambiguity. An NFA is nearly acyclic if any computation can pass through at most one cycle. The class of nearly acyclic NFAs consists of exactly all NFAs with finite depth path width. Using this characterization we show that the finite depth path width of an [Formula: see text]-state NFA over a [Formula: see text]-letter alphabet is at most [Formula: see text] and that this bound is tight. The nearly acyclic NFAs recognize exactly the class of constant density regular languages.

Efficient Algorithms for Computing the Inner Edit Distance of a Regular Language via Transducers

The concept of edit distance and its variants has applications in many areas such as computational linguistics, bioinformatics, and synchronization error detection in data communications. Here, we revisit the problem of computing the inner edit distance of a regular language given via a Nondeterministic Finite Automaton (NFA). This problem relates to the inherent maximal error-detecting capability of the language in question. We present two efficient algorithms for solving this problem, both of which execute in time O ( r 2 n 2 d ) , where r is the cardinality of the alphabet involved, n is the number of transitions in the given NFA, and d is the computed edit distance. We have implemented one of the two algorithms and present here a set of performance tests. The correctness of the algorithms is based on the connection between word distances and error detection and the fact that nondeterministic transducers can be used to represent the errors (resp., edit operations) involved in error-detection (resp., in word distances).

Operations on Unambiguous Finite Automata

A nondeterministic finite automaton is unambiguous if it has at most one accepting computation on every input string. We investigate the state complexity of basic regular operations on languages represented by unambiguous finite automata. We get tight upper bounds for reversal ([Formula: see text]), intersection ([Formula: see text]), left and right quotients ([Formula: see text]), positive closure ([Formula: see text]), star ([Formula: see text]), shuffle ([Formula: see text]), and concatenation ([Formula: see text]). To prove tightness, we use a binary alphabet for intersection and left and right quotients, a ternary alphabet for star and positive closure, a five-letter alphabet for shuffle, and a seven-letter alphabet for concatenation. For complementation, we reduce the trivial upper bound [Formula: see text] to [Formula: see text]. We also get some partial results for union and square.

An Efficient Complex Event Processing Algorithm Based on NFA-HTBTS for Massive RFID Event Stream

This article describes how quickly picking up some valuable information from massive RFID event stream often faces with the problem of long detection time, high memory consumption and low detection efficiency due to its stream characteristics of volume, velocity, variety, value and veracity. Aim to solving the problems above, an efficient complex event processing method based on NFA-HTBTS (Nondeterministic Finite Automaton-Hash Table B+ Tree Structure) is presented in this article. The achievement of this article lies in that we successfully use the union of NFA and HTBTS to realize the detection of complex event in massive RFID event stream. Specially, in our scheme, after using NFA to match related primitive events from massive RFID event stream, we use hash table and B+ tree structure to successfully realize the detection of complex event from large matched results above, as a result, these problems existed in current methods above can be effectively solved by our scheme. The simulation results show that our proposed scheme outperforms some general methods for massive RFID event stream.

State Complexity of Neighbourhoods and Approximate Pattern Matching

The neighbourhood of a language [Formula: see text] with respect to an additive distance consists of all strings that have distance at most the given radius from some string of [Formula: see text]. We show that the worst case deterministic state complexity of a radius [Formula: see text] neighbourhood of a language recognized by an [Formula: see text] state nondeterministic finite automaton [Formula: see text] is [Formula: see text]. In the case where [Formula: see text] is deterministic we get the same lower bound for the state complexity of the neighbourhood if we use an additive quasi-distance. The lower bound constructions use an alphabet of size linear in [Formula: see text]. We show that the worst case state complexity of the set of strings that contain a substring within distance [Formula: see text] from a string recognized by [Formula: see text] is [Formula: see text].

An efficient complex event detection model for high proportion disordered RFID event stream

With the aim of solving the detection problems for current complex event detection models in detecting a related event for a complex event from the high proportion disordered RFID event stream due to its big uncertainty arrival, an efficient complex event detection model based on Extended Nondeterministic Finite Automaton (ENFA) is proposed in this paper. The achievement of the paper rests on the fact that an efficient complex event detection model based on ENFA is presented to successfully realize the detection of a related event for a complex event from the high proportion disordered RFID event stream. Specially, in our model, we successfully use a new ENFA-based complex event detection model instead of an NFA-based complex event detection model to realize the detection of the related events for a complex event from the high proportion disordered RFID event stream by expanding the traditional NFA-based detection model, which can effectively address the problems above. The experimental results show that the proposed model in this paper outperforms some general models in saving detection time, memory consumption, detection latency and improving detection throughput for detecting a related event of a complex event from the high proportion out-of-order RFID event stream.

Worst Case Branching and Other Measures of Nondeterminism

Many nondeterminism measures for finite automata have been studied in the literature. The tree width of an NFA (nondeterministic finite automaton) counts the number of leaves of computation trees as a function of input length. The trace of an NFA is defined in terms of the largest product of the degrees of nondeterministic choices in computations on inputs of given length. Branching is the corresponding best case measure based on the product of nondeterministic choices in the computation that minimizes this value. We establish upper and lower bounds for the trace of an NFA in terms of its tree width. We give a tight bound for the size blow-up of determinizing an NFA with finite trace. Also we show that the trace of any NFA either is bounded by a constant or grows exponentially.

SIMULATIONS OF UNARY ONE-WAY MULTI-HEAD FINITE AUTOMATA

We investigate the descriptional complexity of deterministic one-way multi-head finite automata accepting unary languages. It is known that in this case the languages accepted are regular. Thus, we study the increase of the number of states when an n-state k-head finite automaton is simulated by a classical (one-head) deterministic or nondeterministic finite automaton. In the former case upper and lower bounds that are tight in the order of magnitude are shown. For the latter case we obtain an upper bound of O(n2k) and a lower bound of Ω(nk) states. We investigate also the costs for the conversion of one-head nondeterministic finite automata to deterministic k-head finite automata, that is, we trade nondeterminism for heads. In addition, we study how the conversion costs vary in the special case of finite and, in particular, of singleton unary lanuages. Finally, as an application of the simulation results, we show that decidability problems for unary deterministic k-head finite automata such as emptiness or equivalence are LOGSPACE-complete.

Physical Portrayal of Computational Complexity

Computational complexity is examined using the principle of increasing entropy. To consider computation as a physical process from an initial instance to the final acceptance is motivated because information requires physical representations and because many natural processes complete in nondeterministic polynomial time (NP). The irreversible process with three or more degrees of freedom is found intractable when, in terms of physics, flows of energy are inseparable from their driving forces. In computational terms, when solving a problem in the class NP, decisions among alternatives will affect subsequently available sets of decisions. Thus the state space of a nondeterministic finite automaton is evolving due to the computation itself, hence it cannot be efficiently contracted using a deterministic finite automaton. Conversely when solving problems in the class P, the set of states does not depend on computational history, hence it can be efficiently contracted to the accepting state by a deterministic sequence of dissipative transformations. Thus it is concluded that the state set of class P is inherently smaller than the state set of class NP. Since the computational time needed to contract a given set is proportional to dissipation, the computational complexity class P is a proper (strict) subset of NP.