Showing papers on "ω-automaton published in 2008"

Infinite Runs in Weighted Timed Automata with Energy Constraints

Abstract: We study the problems of existence and construction of infinite schedules for finite weighted automata and one-clock weighted timed automata, subject to boundary constraints on the accumulated weight. More specifically, we consider automata equipped with positive and negative weights on transitions and locations, corresponding to the production and consumption of some resource (e.g.energy). We ask the question whether there exists an infinite path for which the accumulated weight for any finite prefix satisfies certain constraints (e.g.remains between 0 and some given upper-bound). We also consider a game version of the above, where certain transitions may be uncontrollable.

Extending finite automata to efficiently match Perl-compatible regular expressions

Abstract: Regular expression matching is a crucial task in several networking applications. Current implementations are based on one of two types of finite state machines. Non-deterministic finite automata (NFAs) have minimal storage demand but have high memory bandwidth requirements. Deterministic finite automata (DFAs) exhibit low and deterministic memory bandwidth requirements at the cost of increased memory space. It has already been shown how the presence of wildcards and repetitions of large character classes can render DFAs and NFAs impractical. Additionally, recent security-oriented rule-sets include patterns with advanced features, namely back-references, which add to the expressive power of traditional regular expressions and cannot therefore be supported through classical finite automata.In this work, we propose and evaluate an extended finite automaton designed to address these shortcomings. First, the automaton provides an alternative approach to handle character repetitions that limits memory space and bandwidth requirements. Second, it supports back-references without the need for back-tracking in the input string. In our discussion of this proposal, we address practical implementation issues and evaluate the automaton on real-world rule-sets. To our knowledge, this is the first high-speed automaton that can accommodate all the Perl-compatible regular expressions present in the Snort network intrusion and detection system.

Finite automata for caching in matrix product algorithms

Abstract: A diagram is introduced for visualizing matrix product states which makes transparent a connection between matrix product factorizations of states and operators, and complex weighted finite state automata. It is then shown how one can proceed in the opposite direction: writing an automaton that ``generates'' an operator gives one an immediate matrix product factorization of it. Matrix product factorizations have the advantage of reducing the cost of computing expectation values by facilitating caching of intermediate calculations. Thus our connection to complex weighted finite state automata yields insight into what allows for efficient caching in matrix product algorithms. Finally, these techniques are generalized to the case of multiple dimensions.

Finite Automata, Digraph Connectivity, and Regular Expression Size

Abstract: Recently lower bounds on the minimum required size for the conversion of deterministic finite automata into regular expressions and on the required size of regular expressions resulting from applying some basic language operations on them, were given by Gelade and Neven [8]. We strengthen and extend these results, obtaining lower bounds that are in part optimal, and, notably, the presented examples are over a binary alphabet, which is best possible. To this end, we develop a different, more versatile lower bound technique that is based on the star height of regular languages. It is known that for a restricted class of regular languages, the star height can be determined from the digraph underlying the transition structure of the minimal finite automaton accepting that language. In this way, star height is tied to cycle rank, a structural complexity measure for digraphs proposed by Eggan and Buchi, which measures the degree of connectivity of directed graphs.

Complementation, Disambiguation, and Determinization of Büchi Automata Unified

Abstract: We present a uniform framework for (1) complementing Buchi automata, (2) turning Buchi automata into equivalent unambiguous Buchi automata, and (3) turning Buchi automata into equivalent deterministic automata. We present the first solution to (2) which does not make use of McNaughton's theorem (determinization) and an intuitive and conceptually simple solution to (3). Our results are based on Muller and Schupp's procedure for turning alternating tree automata into non-deterministic ones.

The Non-deterministic Mostowski Hierarchy and Distance-Parity Automata

Abstract: Given a Rabin tree-language and natural numbers i,j, the language is said to be i,j-feasible if it is accepted by a parity automaton using priorities {i,i+ 1,...,j}. The i,j-feasibility induces a hierarchy over the Rabin-tree languages called the Mostowski hierarchy. In this paper we prove that the problem of deciding if a language is i,j-feasible is reducible to the uniform universality problem for distance-parity automata. Distance-parity automata form a new model of automata extending both the nested distance desert automata introduced by Kirsten in his proof of decidability of the star-height problem, and parity automata over infinite trees. Distance-parity automata, instead of accepting a language, attach to each tree a cost in i¾?+ 1. The uniform universality problem consists in determining if this cost function is bounded by a finite value.

Computing simulations over tree automata: efficient techniques for reducing tree automata

Abstract: We address the problem of computing simulation relations over tree automata. In particular, we consider downward and upward simulations on tree automata, which are, loosely speaking, analogous to forward and backward relations over word automata. We provide simple and efficient algorithms for computing these relations based on a reduction to the problem of computing simulations on labelled transition systems. Furthermore, we show that downward and upward relations can be combined to get relations compatible with the tree language equivalence, which can subsequently be used for an efficient size reduction of nondeterministic tree automata. This is of a very high interest, for instance, for symbolic verification methods such as regular model checking, which use tree automata to represent infinite sets of reachable configurations. We provide experimental results showing the efficiency of our algorithms on examples of tree automata taken from regular model checking computations.

Three Lectures on Automatic Structures

Abstract: This paper grew out of three tutorial lectures on automatic structures given by the first author at the Logic Colloquium 2007. We discuss variants of automatic structures related to several models of computation: word automata, tree automata, Buchi automata, and Rabin automata. Word automata process finite strings, tree automata process finite labeled trees, Buchi automata process infinite strings, and Rabin automata process infinite binary labeled trees. Automatic structures are mathematical objects which can be represented by (word, tree, Buchi, or Rabin) automata. The study of properties of automatic structures is a relatively new and very active area of research.

Optimal lower bounds on regular expression size using communication complexity

Abstract: The problem of converting deterministic finite automata into (short) regular expressions is considered. It is known that the required expression size is 2Θ(n) in the worst case for infinite languages, and for finite languages it is nΩ(log log n) and nO(log n), if the alphabet size grows with the number of states n of the given automaton. A new lower bound method based on communication complexity for regular expression size is developed to show that the required size is indeed nΘ(log n). For constant alphabet size the best lower bound known to date is Ω(n2), even when allowing infinite languages and nondeterministic finite automata. As the technique developed here works equally well for deterministic finite automata over binary alphabets, the lower bound is improved to nΩ(log n).

Tree-Walking Automata Do Not Recognize All Regular Languages

Abstract: Tree-walking automata are a natural sequential model for recognizing tree languages. It is well known that every tree language recognized by a tree-walking automaton is regular. We show that the converse does not hold.

Coalgebraic automata theory: basic results

Abstract: We generalize some of the central results in automata theory to the abstraction level of coalgebras and thus lay out the foundations of a universal theory of automata operating on infinite objects. Let F be any set functor that preserves weak pullbacks. We show that the class of recognizable languages of F-coalgebras is closed under taking unions, intersections, and projections. We also prove that if a nondeterministic F-automaton accepts some coalgebra it accepts a finite one of the size of the automaton. Our main technical result concerns an explicit construction which transforms a given alternating F-automaton into an equivalent nondeterministic one, whose size is exponentially bound by the size of the original automaton.

Hopcroft's Algorithm and Cyclic Automata

Abstract: Minimization of deterministic finite automata is a largely studied problem of the Theory of Automata and Formal Languages. It consists in finding the unique (up to isomorphism) minimal deterministic automaton recognizing a set of words. The first approaches to this topic can be traced back to the 1950's with the works of Huffman and Moore (cf. [12,15]). Over the years several methods to solve this problem have been proposed but the most efficient algorithm in the worst case was given by Hopcroft in [11]. Such an algorithm computes in O(nlogn) the minimal automaton equivalent to a given automaton with nstates. The Hopcroft's algorithm has been widely studied, described and implemented by many authors (cf. [13,4,16,2]). In particular, in [4] the worst case of the algorithm is considered. The authors of [4] introduce an infinite family of automata associated to circular words. The circular words taken into account are the de Bruijn words, and, by using the associated automata, it is shown that the complexity of the algorithm is tight. More precisely, the Hopcroft's algorithm has some degrees of freedom (see Section 3) in the sense that there can be several executions of the algorithm on a given deterministic automaton. The running time of such executions can be different. With regard to the family of automata proposed in [4] it is shown that there exist some "unlucky" sequences of choices that slow down the computation to achieve the bound Ω(nlogn). However, there are also executions that run in linear time for the same automata. The authors of [4] leave the open problem whether there are automata on which all the executions of Hopcroft's algorithm do not run in linear time. In [16] the author proves that the exact worst case (i.e. in terms of the exact number of operations) of the algorithm for unary languages is reached only for the family of automata given in [4] when a queue is used in the implementation. He remarks that a stack implementation is more convenient for such automata. At the same time in [16] the author conjectures that there is a strategy for processing the stack used in the implementation such that the minimization of all unary languages will be realized in linear time by the Hopcroft's algorithm.

Propositional Automata and Cell Automata: Representational Frameworks for Discrete Dynamic Systems

Abstract: This paper describes and compares two simple, powerful models for formalizing the behavior of discrete dynamic systems: Propositional and Cell Automata. Propositional Automata encode state in terms of boolean propositions, and behavior in terms of boolean gates and latches. Cell Automata generalize the propositional model by encoding state in terms of multi-valued cells, and behavior in terms of comparators and selectors that respond to cell values. While the models are equally expressive, Cell Automata are computationally more efficient than Propositional Automata. Additionally, arbitrary Propositional Automata can be converted to optimal Cell Automata with identical behavioral properties, and Cell Automata can be encoded as a Propositional Automata with only logarithmic increase in size.

An Infinite Automaton Characterization of Double Exponential Time

Abstract: Infinite-state automata are a new invention: they are automata that have an infinite number of states represented by words, transitions defined using rewriting, and with sets of initial and final states. Infinite-state automata have gained recent interest due to a remarkable result by Morvan and Stirling, which shows that automata with transitions defined using rational rewriting precisely capture context-sensitive ( NLinSpace) languages. In this paper, we show that infinite automata defined using a form of multi-stack rewriting precisely defines double exponential time (more precisely, 2ETime , the class of problems solvable in $2^{2^{O(n)}}$ time). The salient aspect of this characterization is that the automata have no ostensible limits on time nor space, and neither direction of containment with respect to 2ETime is obvious. In this sense, the result captures the complexity class qualitatively, by restricting the power of rewriting.

Provably Shorter Regular Expressions from Deterministic Finite Automata

Abstract: We study the problem of finding good elimination orderings for the state elimination algorithm, which is one of the most popular algorithms for the conversion of finite automata into equivalent regular expressions. Based on graph separator techniques we are able to describe elimination strategies that remove states in large induced subgraphs that are "simple" like, e.g., independent sets or subgraphs of bounded treewidth, of the underlying automaton, that lead to regular expressions of moderate size. In particular, we show that there is an elimination ordering such that every language over a binary alphabet accepted by an n-state deterministicfinite automaton has alphabetic width at most O(1.742n), which is, to our knowledge, the algorithm with currently the best known performance guarantee. Finally, we apply our technique to the question on the effect of language operations on regular expression size. In case of the intersection operation we prove an upper bound which matches, up to a small factor, a lower bound recently obtained in [9,10], and thus settles an open problem stated in [7].

Five Determinisation Algorithms

Abstract: Determinisation of nondeterministic finite automata is a well-studied problem that plays an important role in compiler theory and system verification. In the latter field, one often encounters automata consisting of millions or even billions of states. On such input, the memory usage of analysis tools becomes the major bottleneck. In this paper we present several determinisation algorithms, all variants of the well-known subset construction, that aim to reduce memory usage and produce smaller output automata. One of them produces automata that are already minimal. We apply our algorithms to determinise automata that describe the possible sequences appearing after a fixed-length run of cellular automaton 110, and obtain a significant improvement in both memory and time efficiency.

Non-constructive methods for finite probabilistic automata

Abstract: Size (the number of states) of finite probabilistic automata with an isolated cut-point can be exponentially smaller than the size of any equivalent finite deterministic automaton. However, the proof is non-constructive. The result is presented in two versions. The first version depends on Artin's Conjecture (1927) in Number Theory. The second version does not depend on conjectures not proved but the numerical estimates are worse. In both versions the method of the proof does not allow an explicit description of the languages used. Since our finite probabilistic automata are reversible, these results imply a similar result for quantum finite automata.

Embedding finite automata within regular expressions

Abstract: Regular expressions and their extensions have become a major component of industry-oriented specification languages such as IEEE PSL [IEEE Standard for Property Specification Language (PSL). IEEE Std 1850(TM)-2005]. The model checking procedure of regular expression based formulas, involves constructing an automaton which runs in parallel with the model. In this paper we re-examine the automata construction. We propose an algorithm that allows an intermediate representation mixing both regular expressions and automata. This representation can be thought of as plugging an automaton inside a regular expression, to replace an existing sub-expression. In order to be verified, the intermediate representation is then translated into another automaton, resulting in a set of automata running in parallel. A key feature of this algorithm is that the plug-in automaton is independent of the regular expression from which it originated, and thus can be used in several different properties. We demonstrate the usefulness of our method by providing a set of applications. We show how the use of our method allows modularity and flexibility of the automata construction, and can increase expressiveness when seres are mixed with ctl. We give two applications for which it significantly reduces the size of the automata built for formulas, thus reducing the overall run time of the model checking procedure.

The Synchronization Problem for Strongly Transitive Automata

Abstract: The synchronization problem is investigated for a new class of deterministic automata called strongly transitive. An extension to unambiguous automata is also considered.

Inclusion dynamics hybrid automata

Abstract: Hybrid systems are dynamical systems with the ability to describe mixed discrete-continuous evolution of a wide range of systems. Consequently, at first glance, hybrid systems appear powerful but recalcitrant, neither yielding to analysis and reasoning through a purely continuous-time modeling as with systems of differential equations, nor open to inferential processes commonly used for discrete state-transition systems such as finite state automata. A convenient and popular model, called hybrid automata, was introduced to model them and has spurred much interest on its tractability as a tool for inference and model checking in a general setting. Intuitively, a hybrid automaton is simply a ''finite-state'' automaton with each state augmented by continuous variables, which evolve according to a set of well-defined continuous laws, each specified separately for each state. This article investigates both the notion of hybrid automaton and the model checking problem over such a structure. In particular, it relates first-order theories and analysis results on multivalued maps and reduces the bounded reachability problem for hybrid automata whose continuous laws are expressed by inclusions (x'@?f(x,t)) to a decidability problem for first-order formulaeover the reals. Furthermore, the paper introduces a class of hybrid automata for which the reachability problem can be decided and shows that the problem of deciding whether a hybrid automaton belongs to this class can be again decided using first-order formulaeover the reals. Despite the fact that the bisimulation quotient for this class of hybrid automata can be infinite, we show that our techniques permit effective model checking for a nontrivial fragment of CTL.

Nondeterministic Finite Automata--Recent Results on the Descriptional and Computational Complexity

Abstract: Nondeterministic finite automata (NFAs) were introduced in [67], where their equivalence to deterministic finite automata was shown. Over the last 50 years, a vast literature documenting the importance of finite automata as an enormously valuable concept has been developed. In the present paper, we tour a fragment of this literature. Mostly, we discuss recent developments relevant to NFAs related problems like, for example, (i) simulation of and by several types of finite automata, (ii) minimization and approximation, (iii) size estimation of minimal NFAs, and (iv) state complexity of language operations. We thus come across descriptional and computational complexity issues of nondeterministic finite automata. We do not prove these results but we merely draw attention to the big picture and some of the main ideas involved.

Alternation Elimination by Complementation (Extended Abstract)

Abstract: In this paper, we revisit constructions from the literature that translate alternating automata into language-equivalent nondeterministic automata. Such constructions are of practical interest in finite-state model checking, since formulas of widely used linear-time temporal logics with future and past operators can directly be translated into alternating automata. We present a construction scheme that can be instantiated for different automata classes to translate alternating automata into language-equivalent nondeterministic automata. The scheme emphasizes the core ingredient of previously proposed alternation-elimination constructions, namely, a reduction to the problem of complementing nondeterministic automata. Furthermore, we clarify and improve previously proposed constructions for different classes of alternating automata by recasting them as instances of our construction scheme. Finally, we present new complementation constructions for 2-way nondeterministic automata from which we then obtain novel alternation-elimination constructions.

Some Varieties of Finite Tree Automata Related to Restricted Temporal Logics

Abstract: We provide structural descriptions of certain varieties of finite tree automata closed under a version of the cascade product, called the Moore product. As a byproduct, we obtain decidable characterizations of the expressive power of certain fragments of CTL on finite trees.

Fast Signature Matching Using Extended Finite Automaton (XFA)

Abstract: Automata-based representations and related algorithms have been applied to address several problems in information security, and often the automata had to be augmented with additional information. For example, extended finite-state automata (EFSA) augment finite-state automata (FSA) with variables to track dependencies between arguments of system calls. In this paper, we introduce extended finite automata (XFAs) which augment FSAs with finite scratch memory and instructions to manipulate this memory. Our primary motivation for introducing XFAs is signature matching in Network Intrusion Detection Systems (NIDS). Representing NIDS signatures as deterministic finite-state automata (DFAs) results in very fast signature matching but for several types of signatures DFAs can blowup in space. Nondeterministic finite-state automata (NFA) representation of NIDS signatures results in a succinct representation but at the expense of higher time complexity for signature matching. In other words, DFAs are time-efficient but space-inefficient, and NFAs are space-efficient but time-inefficient. Our goal is to find a representation of signatures that is both time and space efficient. In our experiments we have noticed that for a large class of NIDS signatures XFAs have time complexity similar to DFAs and space complexity similar to NFAs. For our test set, XFAs use 10 times less memory than a DFA-based solution, yet achieve 20 times higher matching speeds.

General Algorithms for Testing the Ambiguity of Finite Automata

Abstract: This paper presents efficient algorithms for testing the finite, polynomial, and exponential ambiguity of finite automata with i¾?-transitions. It gives an algorithm for testing the exponential ambiguity of an automaton Ain time $O(|A|_E^2)$, and finite or polynomial ambiguity in time $O(|A|_E^3)$, where |A| E denotes the number of transitions of A. These complexities significantly improve over the previous best complexities given for the same problem. Furthermore, the algorithms presented are simple and based on a general algorithm for the composition or intersection of automata. We also give an algorithm to determine in time $O(|A|_E^3)$ the degree of polynomial ambiguity of a polynomially ambiguous automaton A. Finally, we present an application of our algorithms to an approximate computation of the entropy of a probabilistic automaton.

More Concise Representation of Regular Languages by Automata and Regular Expressions

Abstract: We consider two formalisms for representing regular languages: constant height pushdown automata and straight line programs for regular expressions. We constructively prove that their sizes are polynomially related. Comparing them with the sizes of finite state automata and regular expressions, we obtain optimal exponential and double exponential gaps, i.e., a more concise representation of regular languages.

A note on Černy conjecture for automata over 3-letter alphabet

Abstract: We show that the alphabet size can play an essential role in the issue of automata synchronization. We give an example of 5-state automaton (over 3-letter alphabet) not isomorphic to Cerny's one, with the minimal synchronizing word of length (n-1)2=16. It is known [2] that there is no such automaton for 2-letter alphabet.

Succinct description of regular languages by weak restarting automata

Abstract: The descriptional complexity of restarting automata is investigated. We distinguish the classes of weak restarting automata, i.e., classical restarting automata accepting exactly the regular languages. In order to investigate the descriptional power gained by the additional structural resources of restarting automata, we study the trade-offs in the number of states when changing the representation to classical finite automata. The bounds shown are tight in the exact number of states. Interestingly, for a particular class we can show the tight bounds 2^n+1 and 2^n for DFA and NFA conversion, respectively, by a fooling set technique. So, the power gained by the resources given to restarting automata seems to be different compared with nondeterminism.