Showing papers on "Büchi automaton published in 2002"

A Hierarchy of Polynomial-Time Computable Simulations for Automata

Abstract: We define and provide algorithms for computing a natural hierarchy of simulation relations on the state-spaces of ordinary transition systems, finite automata, and Buchi automata.T hese simulations enrich ordinary simulation and can be used to obtain greater reduction in the size of automata by computing the automaton quotient with respect to their underlying equivalence.Sta te reduction for Buchi automata is useful for making explicit-state model checking run faster ([EH00, SB00, EWS01]).We define k-simulations, where 1-simulation corresponds to ordinary simulation and its variants for Buchi automata ([HKR97, EWS01]), and k-simulations, for k > 1, generalize the game definition of 1-simulation by allowing the Duplicator to use k pebbles instead of 1 (to "hedge its bets") in response to the Spoiler's move of a single pebble.As k increases, ksimulations are monotonically non-decreasing relations. Indeed, when k reaches n, the number of states of the automaton, the n-simulations defined for finite-automata and for labeled transition systems correspond precisely to language containment and trace containment, respectively. But for each fixed k, the maximal k-simulation relation is computable in polynomial time: nO(k).This provides a mechanism with which to trade off increased computing time for larger simulation relation size, and more potential reduction in automaton size.W e provide algorithms for computing k-simulations using a natural generalization of a prior efficient algorithm based on parity games ([EWS01]) for computing various simulations.Lastly, we observe the relationship between k-simulations and a k-variable interpretation of modal logic.

Systems and methods for generating weighted finite-state automata representing grammars

Abstract: A context-free grammar can be represented by a weighted finite-state transducer. This representation can be used to efficiently compile that grammar into a weighted finite-state automaton that accepts the strings allowed by the grammar with the corresponding weights. The rules of a context-free grammar are input. A finite-state automaton is generated from the input rules. Strongly connected components of the finite-state automaton are identified. An automaton is generated for each strongly connected component. A topology that defines a number of states, and that uses active ones of the non-terminal symbols of the context-free grammar as the labels between those states, is defined. The topology is expanded by replacing a transition, and its beginning and end states, with the automaton that includes, as a state, the symbol used as the label on that transition. The topology can be fully expanded or dynamically expanded as required to recognize a particular input string.

From States to Transitions: Improving Translation of LTL Formulae to Büchi Automata

Abstract: Model checking is an automated technique for checking that a system satisfies a set of required properties. With explicit-state model checkers, properties are typically defined in linear-time temporal logic (LTL), and are translated into Buchi automata in order to be checked. This paper describes how, by labeling automata transitions rather than states, we significantly reduce the size of automata generated by existing tableau-based translation algorithms. Our optimizations apply to the core of the translation process, where generalized Buchi automata are constructed. These automata are subsequently transformed in a single efficient step into Buchi automata as used by model checkers. The tool that implements the work described here is released as part of the Java Path-Finder software (JPF), an explicit state model checker of Java programs under development at the NASA Ames Research Center.

Constructing automata from temporal logic formulas: a tutorial

Abstract: This paper presents a tutorial introduction to the construction of finite-automata on infinite words from linear-time temporal logic formulas. After defining the source and target formalisms, it describes a first construction whose correctness is quite direct to establish, but whose behavior is always equal to the worst-case upper bound. It then turns to the techniques that can be used to improve this algorithm in order to obtain the quite effective algorithms that are now in use.

Fair Simulation Minimization

Abstract: We present an algorithm for the minimization of Buchi automata based on the notion of fair simulation introduced in [6] . Unlike direct simulation, fair simulation allows flexibility in the satisfaction of the acceptance conditions, and hence leads to larger relations. However, it is not always possible to remove edges to simulated states or merge simulation-equivalent states without altering the language of the automaton. Solutions proposed in the past consisted in checking sufficient conditions [11, Theorem 3], or resorting to more restrictive notions like delayed simulation [5]. By contrast, our algorithm exploits the full power of fair simulation by efficiently checking the correctness of changes to the automaton (both merging of states and removal of edges).

Testing LTL formula translation into Büchi automata

Abstract: Model checkers are often used to verify critical systems, and thus a lot of effort should be put on ensuring their reliability. We describe techniques for testing linear temporal logic (LTL) model checker implementations, focusing especially on LTL-to-Buchi automata translation. We propose a randomized testing approach based on the cross-comparison of independent translator implementations, and present methods for test failure analysis. We give experimental results using an automated tool implementing the testing methodology. This method has helped to detect errors in model checking tools such as Spin. We also propose extending LTL model checkers with a simple counterexample validation algorithm.

Fair simulation minimization

Abstract: We present an algorithm for the minimization of Buchi automata based on the notion of fair simulation introduced in [6]. Unlike direct simulation, fair simulation allows flexibility in the satisfaction of the acceptance conditions, and hence leads to larger relations. However, it is not always possible to remove edges to simulated states or merge simulation-equivalent states without altering the language of the automaton. Solutions proposed in the past consisted in checking sufficient conditions [11, Theorem 3], or resorting to more restrictive notions like delayed simulation [5]. By contrast, our algorithm exploits the full power of fair simulation by efficiently checking the correctness of changes to the automaton (both merging of states and removal of edges).

On the Construction of Reversible Automata for Reversible Languages

Abstract: Reversible languages occur in many different domains Although the decision for the membership of reversible languages was solved in 1992 by Pin, an effective construction of a reversible automaton for a reversible language was still unknown We give in this paper a method to compute a reversible automaton from the minimal automaton of a reversible language With this intention, we use the universal automaton of the language that can be obtained from the minimal automaton and that contains an equivalent automaton which is quasi-reversible This quasi-reversible automaton has nearly the same properties as a reversible one and can easily be turned into a reversible automaton

State Space Reductions for Alternating Büchi Automata Quotienting by Simulation Equivalences

Abstract: Quotienting by simulation equivalences is a well-established technique for reducing the size of nondeterministic Buchi automataWe adapt this technique to alternating Buchi automata To this end we suggest two new quotients, namely minimax and semi-elective quotients, prove that they preserve the recognized languages, and show that computing them is not more difficult than computing quotients for nondeterministic Buchi automata We explain the merits of of our quotienting procedures with respect to converting alternating Buchi automata into nondeterministic ones

Model Checking Linear Properties of Prefix-Recognizable Systems

Abstract: We develop an automata-theoretic framework for reasoning about linear properties of infinite-state sequential systems. Our framework is based on the observation that states of such systems, which carry a finite but unbounded amount of information, can be viewed as nodes in an infinite tree, and transitions between states can be simulated by finite-state automata. Checking that the system satisfies a temporal property can then be done by an alternating two-way automaton that navigates through the tree. We introduce path automata on trees. The input to a path automaton is a tree, but the automaton cannot split to copies and it can read only a single path of the tree. In particular, two-way nondeterministic path automata enable exactly the type of navigation that is required in order to check linear properties of infinite-state sequential systems.We demonstrate the versatility of the automata-theoretic approach by solving several versions of the model-checking problem for LTL specifications and prefix-recognizable systems. Our algorithm is exponential in both the size of (the description of) the system and the size of the LTL specification, and we prove a matching lower bound. This is the first optimal algorithm for solving the LTL model-checking problem for prefix recognizable systems. Our framework also handles systems with regular labeling.

Common subsequence automaton

Abstract: Given a set of strings, a common subsequence of this set is a string that is a subsequence of each string in this set. We describe an on-line algorithm building the finite automaton that accepts all common subsequences of the given set of strings.

Model Checking Linear Properties of Prefix-Recognizable Systems

Abstract: We develop an automata-theoretic framework for reasoning about linear properties of infinite-state sequential systems. Our framework is based on the observation that states of such systems, which carry a finite but unbounded amount of information, can be viewed as nodes in an infinite tree, and transitions between states can be simulated by finite-state automata. Checking that the system satisfies a temporal property can then be done by an alternating two-way automaton that navigates through the tree. We introduce path automata on trees. The input to a path automaton is a tree, but the automaton cannot split to copies and it can read only a single path of the tree. In particular, two-way nondeterministic path automata enable exactly the type of navigation that is required in order to check linear properties of infinite-state sequential systems. We demonstrate the versatility of the automata-theoretic approach by solving several versions of the model-checking problem for LTL specifications and prefix-recognizable systems. Our algorithm is exponential in both the size of (the description of) the system and the size of the LTL specification, and we prove a matching lower bound. This is the first optimal algorithm for solving the LTL model-checking problem for prefix recognizable systems. Our framework also handles systems with regular labeling.

Constructing NFAs by optimal use of positions in regular expressions

Abstract: We give two new algorithms for constructing small nondeterministic finite automata (NFA) from regular expressions. The first constructs NFAs with e-moves (eNFA) which are smaller than all the other eNFAs obtained by similar constructions. Their size is at most 3/2|α| + 5/2, where a is the regular expression. The second constructs NFAs. It uses e-elimination in the eNFAs we just introduced and builds a quotient of the well-known position automaton. Our NFA is always smaller and faster to compute than the position automaton. It uses optimally the information from the positions of a regular expression.

Star Height of Reversible Languages and Universal Automata

Abstract: The star height of a regular language is an invariant that has been shown to be effectively computable in 1988 by Hashiguchi. But the algorithm that corresponds to his proof leads to impossible computations even for very small instances. Here we solve the problem (of computing star height) for a special class of regular languages,called reversible languages,tha t have attracted much attention in various areas of formal language and automata theory in the past few years. These reversible languages also strictly extend the classes of languages considered by McNaughton, Cohen, and Hashiguchi for the same purpose, and with different methods.Our method is based upon the definition (inspired by the reading of Conway's book) of an automaton that is effectively associated to every language -- which we call the universal automaton of the language -- and that contains the image of any automaton that accepts the language. We show that the universal automaton of a reversible language contains a subautomaton where the star height can be computed.

State Space Reductions for Alternating Büchi Automata

Abstract: Quotienting by simulation equivalences is a well-established technique for reducing the size of nondeterministic Buchi automata. We adapt this technique to alternating Buchi automata. To this end we suggest two new quotients, namely minimax and semi-elective quotients, prove that they preserve the recognized languages, and show that computing them is not more difficult than computing quotients for nondeterministic Buchi automata. We explain the merits of of our quotienting procedures with respect to converting alternating Buchi automata into nondeterministic ones.

Possible edges of a finite automaton defining a given regular language

Abstract: In this paper we consider non-deterministic finite Rabin-Scott's automata. We define special abstract objects, being pairs of values of states-marking functions. On the basis of these objects as the states of automaton, we define its edges; the obtained structure is considered also as a nondeterministic automaton. We prove, that any edge of any nondeterministic automaton defining the given regular language can be obtained by such techniques. Such structure can be used for solving various problems in the frames of finite automata theory.

Two-Way Alternating Automata and Finite Models

Abstract: A graph extension oft wo-way alternating automata on trees is considered. The following problem: "does a given automaton accept any finite graph?" is proven EXPTIME complete. Using this result, the decidability ofthe finite model problem for the modal µ-calculus with backward modalities is shown.

Alternating tree automata and parity games

Abstract: Since Buchi’s work in 1960 [17], automata play an important role in logic. Numerous different notions of automata provide decision and complexity results in various kinds of logic. Often, one develops a method to translate some given formula ϕ into an appropriate finite automaton A such that L(ϕ) = L(A). Such a translation reduces the model checking problem and the satisfiability problem in some logic to the word problem and the emptiness problem for finite automata. Moreover, such a translation provides algorithms to solve the model checking and the satisfiability problems on a computer. Consequently, one is interested in the decidability and the complexity of the word and emptiness problems of automata.

Theoretical study and implementation of the canonical automaton

Abstract: We can represent the canonical automaton of a language as the smallest automaton which contains any other automaton recognizing this language, providing equivalent states are merged. Indeed, the canonical automaton appears to be a good representative element in the equivalence class of non-deterministic automata recognizing a given language. Our aim is to provide a detailed description of the canonical automaton based on the notions of syntactical rectangle and characteristic event. In our approach, a state of the canonical automaton of a language L is associated with a rectangle (L,R) ⊆ Σ* × Σ*, which is maximal w.r.t. the property L.R ⊆ L. We explicit the link with other characterizations, like considering a state as a residual intersection which was given by Arnold et al., and the fundamental automaton defined by Matz and Potthoff. In particular, we pretend that the construction of the canonical automaton has the same time complexity as the construction of the fundamental automaton. Our last section briefly discusses the problem of searching minimal NFAs using the canonical automaton.

Some properties of the basis finite automaton

Abstract: The present paper discusses non-deterministic finite Rabin-Scott's automata. The majority of works recently dealing with this subject were, in fact, concerned only with properties of a canonical form automata or of some objects equivalent to it. This article continues the series of works in which the authors state a different point of view, describing the finite automata as just another invariant of the given regular language called basis finite automaton. In this article the authors argue on some new properties for the basis finite automaton. One of them is included into basis automaton's table of binary relations. It is stated that this table can not contain either identical strings or identical columns. Another property depicts a possibility to obtain any finite automaton for a given regular language by the process of duplicating or combining some of its states.

Resource-Constrained Model Checking of Recursive Programs

Abstract: A number of recent papers present efficient algorithms for LTL model checking for recursive programs with finite data structures. A common feature in all these works is that they consider infinitely long runs of the program without regard to the size of the program stack. Runs requiring unbounded stack are often a result of abstractions done to obtain a finite-data recursive program. In this paper, we introduce the notion of resource-constrained model checking where we distinguish between stack-diverging runs and finite-stack runs. It should be noted that finiteness of stack-like resources cannot be expressed in LTL. We develop resource-constrained model checking in terms of good cycle detection in a finite graph called R-graph, which is constructed from a given push-down system (PDS) and a Buchi automaton. We make the formulation of the model checker "executable" by encoding it directly as Horn clauses. We present a local algorithm to detect a good cycle in an R-graph. Furthermore, by describing the construction of R-graph as a logic program and evaluating it using tabled resolution, we do model checking without materializing the push-down system or the induced Rgraph. Preliminary experiments indicate that the local model checker is at least as efficient as existing model checkers for push-down systems.

Logics for Mazurkiewicz Traces

Abstract: Linear temporal logic (LTL) has become a well established tool for specifying the dynamic behavior of reactive systems with an interleaving semantics and the automatatheoretic approach has proven to be a very useful mechanism for performing automatic verification in this setting. Especially alternating automata turned out to be a powerful tool in constructing efficient yet simple to understand decision procedures and directly yield on-the-fly model checking procedures. While this technique extends elegantly to richer domains where the underlying computations are modeled as (Mazurkiewicz) traces, it does so only for eventand location-based temporal logics. In this thesis, we exhibit a decision procedure for LTL over Mazurkiewicz traces which generalizes the classical automata-theoretic approach to a linear temporal logic interpreted no longer over sequences but restricted labeled partial orders. Specifically, we construct a (linear) alternating Buchi automaton accepting the set of linearizations of those traces satisfying the formula at hand. The salient point of our technique is to apply a notion of independencerewriting to formulas of the logic. Furthermore, we show that the class of linear and trace-consistent alternating Buchi automata corresponds exactly to LTL formulas over Mazurkiewicz traces, lifting a similar result from Loding and Thomas formulated in the framework of LTL over words. Additionally, a linear temporal logic with a different flavor is introduced as Foata linear temporal logic (LTLf). It is designed for specifying properties of synchronized systems that comprise clocked hardware circuits or Petri nets supplied with a maximal step semantics. Distributed synchronous transition systems (DSTSs) are introduced as formal models of these systems and are equipped with a Foata configuration graph-based semantics, which provides a link between these systems and the framework of Mazurkiewicz traces. To simplify the task of defining DSTSs, we introduce a simple calculus in the spirit of CCS. We give optimal decision procedures for satisfiability of LTLf formulas as well as for model checking, both based on alternating Buchi automata. The model checking procedure further employs an optimization which is similar to a technique known as partial order reduction.

Determinization and complementation of Streett automata

Abstract: Several classes of ω-automata have been proposed in the literature, most importantly Buchi automata, Muller automata, and Rabin automata It has been shown that the expressiveness of all these models is equivalent

Automata-Theoretic Decision Procedures for Information Logics

Abstract: Automata-theoretic decision procedures for solving model-checking and satisfiability problems for temporal, dynamic, and description logics have flourished during the past decades. In the paper we define an EXPTIME decision procedure based on the emptiness problem of Buchi automata on infinite trees for the very expressive information logic SIM designed for reasoning about information systems. This logic involves modal parameters satisfying certain properties to capture the relevant nominals at the formula level, Boolean expressions and nominals at the modal level, an implicit intersection operation for relations, and a universal modality. The original combination of known techniques allows us to solve the open question related to the EXPTIME-completeness of SIM. Furthermore, we discuss how variants of SIM can be treated similarly although the decidability status of some of them is still unknown.

Regular Sets of Descendants by Some Rewrite Strategies

Abstract: For a constructor-based rewrite system R, a regular set of ground terms E, and assuming some additional restrictions, we build a finite tree automaton that recognizes the descendants of E, i.e. the terms issued from E by rewriting, according to innermost, innermost-leftmost, and outermost strategies.