Showing papers on "Büchi automaton published in 2003"
09 May 2003
TL;DR: An algorithm for constructing finite automata recognising informative prefixes of LTL formulas based on [1] is presented and results indicate that the translation is competitive when compared to model checking with tools translating full LTL to Buchi automata.
Abstract: We consider the problems of identifying LTL safety properties and translating them to finite automata. We present an algorithm for constructing finite automata recognising informative prefixes of LTL formulas based on [1]. The implementation also includes a procedure for deciding if a formula is pathologic. Experimental results indicate that the translation is competitive when compared to model checking with tools translating full LTL to Buchi automata.
106 citations
16 Jul 2003
TL;DR: This procedure computes simulation relations for alternating Buchi automata in an early stage and uses them in an on the-fly fashion to decrease the time and space consumption without sacrificing the potential of simulation relations.
Abstract: We present a new procedure for the translation of propositional linear-time temporal logic (LTL) formulas to equivalent nondeterministic Buchi automata. Our procedure is based on simulation relations for alternating Buchi automata. Whereas most of the procedures that have been described in the past compute simulation relations in the last step of the translation (after a nondeterministic Buchi automaton has already been constructed), our procedure computes simulation relations for alternating Buchi automata in an early stage and uses them in an on the-fly fashion. This decreases the time and space consumption without sacrificing the potential of simulation relations.
We present experimental results that demonstrate the advantages of our approach: Our procedure is faster than TMP but produces, on the average, automata of about the same size; LTL2BA is faster than our procedure but produces larger automata.
102 citations
TL;DR: It is proved that, given a probabilistic timed automaton A, there exists a Markov (memoryless) policy which maximizes the probability p of the set of accepting runs realized by this policy, which is computable in polytime in the size of the region automaton of A.
92 citations
TL;DR: This paper builds on a different conjecture and presents an alternative approach in which Buchi automata are generated which are “as deterministic as possible”, in the sense that they try to reduce as much as they are able to the presence of non-deterministic decision states in A ϕ.
Abstract: The standard technique for LTL model checking (\(M \vDash
eg \varphi\)) consists on translating the negation of the LTL specification, ϕ, into a Buchi automaton A ϕ , and then on checking if the product M ×A ϕ has an empty language. The efforts to maximize the efficiency of this process have so far concentrated on developing translation algorithms producing Buchi automata which are “as small as possible”, under the implicit conjecture that this fact should make the final product smaller. In this paper we build on a different conjecture and present an alternative approach in which we generate instead Buchi automata which are “as deterministic as possible”, in the sense that we try to reduce as much as we are able to the presence of non-deterministic decision states in A ϕ . We motivate our choice and present some empirical tests to support this approach.
83 citations
TL;DR: This approach is based on optimizations of both the intermediate weak alternating automaton and the final nondeterministic automaton, and involves techniques of rank and height reductions, as well as direct and fair simulation.
Abstract: Several optimal algorithms have been proposed for the complementation of nondeterministic Buchi word automata. Due to the intricacy of the problem and the exponential blow-up that complementation involves, these algorithms have never been used in practice, even though an effective complementation construction would be of significant practical value. Recently, Kupferman and Vardi described a complementation algorithm that goes through weak alternating automata and that seems simpler than previous algorithms. We combine their algorithm with known and new minimization techniques. Our approach is based on optimizations of both the intermediate weak alternating automaton and the final nondeterministic automaton, and involves techniques of rank and height reductions, as well as direct and fair simulation.
68 citations
TL;DR: The main result of the paper is that any rational set of infinite words is recognized by such an automaton called unambiguous, and two proofs of this result are given.
55 citations
25 Aug 2003
TL;DR: This paper proposes a translation procedure of PLTL (LTL with past modalities) formulas to Buchi automata using two-way very-weak alternating automata (2VWAA) as an intermiediary step and produces an efficient translation of 2VWAA to generalized BBA.
Abstract: In this paper, we propose a translation procedure of PLTL (LTL with past modalities) formulas to Buchi automata using two-way very-weak alternating automata (2VWAA) as an intermiediary step. Our main result is an efficient translation of 2VWAA to generalized Buchi automata (GBA).
49 citations
07 Apr 2003
TL;DR: It is show that the distinction between syntactic and semantic failure has a dramatic impact on the complexity of using the language in a model-checking tool, and it is proved that Reset-LTL enjoys the "fast-compilation property", which implies a linear translation of Reset- LTL formulas into alternating Buchi automata.
Abstract: There has been a major emphasis recently in the semiconductor industry on designing industrial-strength property specification languages. Two major languages are ForSpec and Sugar 2.0, which are both extensions of Pnueli's LTL. Both ForSpec and Sugar 2.0 directly support reset/abort signals, in which a check for a property ψ may be terminated and declared successful by a reset/abort signal, provided the check has not yet failed. ForSpec and Sugar 2.0, however, differ in their definition of failure. The definition of failure in ForSpec is syntactic, while the definition in Sugar 2.0 is semantic. In this work we examine the implications of this distinction between the two approaches, which we refer to as the reset approach (for ForSpec) and the abort approach (for Sugar 2.0). In order to focus on the reset/abort issue, we do not consider the full languages, which are quite rich, but rather the extensions of LTL with the reset/abort constructs.
We show that the distinction between syntactic and semantic failure has a dramatic impact on the complexity of using the language in a model-checking tool. We prove that Reset-LTL enjoys the "fast-compilation property": there is a linear translation of Reset-LTL formulas into alternating Buchi automata, which implies a linear translation of Reset-LTL formulas into a symbolic representation of nondeterministic Buchi automata. In contrast, the translation of Abort-LTL formulas into alternating Buchi automata is nonelementary (i.e., cannot be bounded by a stack of exponentials of a bounded height); each abort yields an exponential blow-up in the translation. This complexity bounds also apply to model checking; model checking Reset-LTL formulas is exponential in the size of the property, while model checking Abort-LTL formulas is nonelementary in the size of the property (the same bounds apply to satisfiability checking).
34 citations
08 Jul 2003
TL;DR: In this article, the authors consider the problem of checking abstraction between two finite-state fair discrete systems and propose a triply nested μ-calculus formula which can be implemented by symbolic methods.
Abstract: The paper considers the problem of checking abstraction between two finite-state fair discrete systems. In automata-theoretic terms this is trace inclusion between two Streett automata. We propose to reduce this problem to an algorithm for checking fair simulation between two generalized Buchi automata. For solving this question we present a new triply nested μ-calculus formula which can be implemented by symbolic methods.
29 citations
08 Jul 2003
TL;DR: This paper considers the case when the specification is given as a deterministic Buchi automaton, and shows the problem to be decidable, and presents a solution based on two-way alternating tree automata with time complexity that is polynomial in the number of internal nodes, exponential in the specification and exponential inThe number of exits of the components.
Abstract: In this paper, we focus on solving games in recursive game graphs that can model the control flow of sequential programs with recursive procedure calls. The winning condition is given as an ω-regular specification over the observable, and, unlike traditional pushdown games, the strategy is required to be modular: resolution of choices within a component should not depend on the context in which the component is invoked, but only on the history within the current invocation of the component. We first consider the case when the specification is given as a deterministic Buchi automaton. We show the problem to be decidable, and present a solution based on two-way alternating tree automata with time complexity that is polynomial in the number of internal nodes, exponential in the specification and exponential in the number of exits of the components. We show that the problem is Exptime-complete in general, and Np-complete for fixed-size specifications. Then, we show that the same complexity bounds apply if the specification is given as a universal co-Buchi automaton. Finally, for specifications given as formulas of linear temporal logic Ltl, we obtain a synthesis algorithm that is doubly-exponential in the formula and singly exponential in the number of exits of components.
26 citations
16 Jul 2003
TL;DR: It is shown that given a Buchi automaton specifying the desired set of conversations, called a conversation protocol, it is possible to implement it using a set of finite state peers if three realizability conditions are satisfied.
Abstract: This paper focuses on the realizability problem of a framework for modeling and specifying the global behavior of reactive electronic services (e-services). In this framework, Web accessible programs (peers) communicate by asynchronous message passing, and a virtual global watcher listens silently to the network. The global behavior is characterized by a conversation, which is the infinite sequence of messages observed by the watcher. We show that given a Buchi automaton specifying the desired set of conversations, called a conversation protocol, it is possible to implement it using a set of finite state peers if three realizability conditions are satisfied. In particular, the synthesized peers will conform to the protocol by generating only those conversations specified by the protocol. Our results enable a top-down verification strategy where: (1) A conversation protocol is specified by a realizable Buchi automaton, (2) The properties of the protocol are verified on the Buchi automaton specification, (3) The peer implementations are synthesized from the protocol via projection.
07 Jul 2003
TL;DR: In this article, the relationship between the minimal automaton, the universal automaton and the syntactic monoid of a regular language is discussed, and certain completions and reductions of the transformation matrix of the automaton are discussed.
Abstract: We discuss the relationships between the minimal automaton, the universal automaton, the syntactic monoid and the syntactic semiring of a given regular language We use certain completions and reductions of the transformation matrix of the minimal automaton to clarify those connections
Journal Article•
TL;DR: Certain completions and reductions of the transformation matrix of the minimal automaton are used to clarify connections between the relationships between the minimal Automaton, the universal automaton,The syntactic monoid and the syntactic semiring of a given regular language.
Abstract: We discuss the relationships between the minimal automaton, the universal automaton, the syntactic monoid and the syntactic semiring of a given regular language. We use certain completions and reductions of the transformation matrix of the minimal automaton to clarify those connections.
TL;DR: A study on how students perceived non-determinism of finite automata in a theoretical unit on computational models found that many students did not choose the easiest way to solve the problem: Many students preferred to construct a deterministic automaton, even though constructing a non-Determinism automaton for the language is much simpler.
Abstract: One of the units in the relatively new high school CS curriculum which is being implemented in Israel is a theoretical unit on computational models. It includes deterministic and non-deterministic finite automata, regular and non-regular languages, closure properties of regular languages, pushdown automata, closure properties of context free languages, turing machines, the church-turing thesis and the halting problem. This paper focuses on part of a study we conducted on the unit, dealing with the topic of non-determinism of finite automata. One of the aspects dealt with was how students perceived non-determinism. 339 students were given a relatively complicated regular language, and asked to construct a finite automaton that accepts this language. We found that many students did not choose the easiest way to solve the problem: Many students preferred to construct a deterministic automaton, even though constructing a non-deterministic automaton for the language is much simpler. We analyze and categorize the students' solutions, thus shedding some light on their perception of the abstract concept of non-determinism.
01 Jan 2003
TL;DR: This paper proposes an algorithm to decide language emptiness for the subclass of weak alternating automata that result from the translation of LTL formulas, and computes strongly connected components of the graph of reachable configurations, the emptiness criterion being expressed in terms of the set of self loops that can be avoided within an SCC.
Abstract: The automata-theoretic approach to model checking requires two basic ingredients: a translation from logic to automata, and an algorithm for checking language emptiness. LTL model checking has traditionally been based on (generalized) Buchi automata. Weak alternating automata provide an attractive alternative because there is an elegant and linear-time translation from LTL. However, due to their intricate combinatorial structure, no direct algorithm for deciding the emptiness problem for these automata has been known, and implementations have relied on an exponential translation of weak alternating to nondeterministic Buchi automata. In this paper, we fill this gap by proposing an algorithm to decide language emptiness for the subclass of weak alternating automata that result from the translation of LTL formulas. Our approach makes use of two observations: first, runs of weak alternating automata can be represented as dags and second, the transition graphs of linear weak alternating automata are of restricted combinatorial structure. Our algorithm computes strongly connected components of the graph of reachable configurations, the emptiness criterion being expressed in terms of the set of self loops that can be avoided within an SCC.
22 Apr 2003
TL;DR: A new methodology for model checking real-time systems based on the abstraction of time predicates is presented, which generates an untimed automaton representing an equivalent finite state system to be model checked using existing tools.
Abstract: This paper presents a new methodology for model checking real-time systems based on the abstraction of time predicates. A real-time system is modeled with a timed automaton which is translated to a real-time program. The properties are specified with the temporal logic TCTL (timed computational tree logic). The real-time program and the TCTL property are used first, for producing a new automaton which augments the original with auxiliary clocks capturing the timing constraints in the TCTL specification that is reduced to an equivalent CTL specification. Second, the augmented real-time program is converted to a well timed system by removing the zeno runs (that are executions in which time does not diverge). Then the time predicates in the augmented automaton which is represented by an augmented and no-zeno real-time program will be abstracted to generate an untimed automaton representing an equivalent finite state system to be model checked using existing tools.
01 Nov 2003
TL;DR: In this paper, the authors give a criterion for a sequence (an)n − 1 to be non-automatic, i.e., for when there does not exist a flnite automaton generating this sequence.
Abstract: We give a criterion for a sequence (an)n‚1 to be non-automatic, i.e., for when there does not exist a flnite automaton generating this sequence. As application we generalize a result of Yazdani on the non-automaticity of multiplicative sequences.
Journal Article•
TL;DR: An approach of model checking UML Statecharts is given and Linear temporal logic properties of the system can be verified based on the automata theory of modelchecking.
Abstract: UML (unified modeling language) has been widely used in software development. Verifying if a UML model meets the required properties has become a key issue. An approach of model checking UML Statecharts is given in this paper. At first, the UML Statecharts is structurally expressed by extended hierarchical automata. Then, the deduction rules of operational semantics are defined. The correctness of operational semantics can be ensured through finding the maximal non-conflict transition set. For the system with infinite runs, the operational semantics can be mapped to a Buchi automaton. Linear temporal logic properties of the system can be verified based on the automata theory of model checking. The method of verifying a complex multi-object system modeled by Statecharts and collaboration diagram is also presented in this paper.
16 Jul 2003
TL;DR: It is shown that any bideterministic automaton is the unique minimal automaton among all (including nondeterministic) automata accepting the same language.
Abstract: Bideterministic automata are deterministic automata with the property of their reversal automata also being deterministic. It has been known that a bideterministic automaton is the minimal deterministic automaton accepting its language. This paper shows that any bideterministic automaton is the unique minimal automaton among all (including nondeterministic) automata accepting the same language. We also present a more general result that shows that under certain conditions a minimal deterministic automaton accepting some language or the reversal of the minimal deterministic automaton of the reversal language is a minimal automaton representation of the language. These conditions can be checked in polynomial time.
Journal Article•
TL;DR: It is shown that there are regular languages where the use of kC-OCAs cannot reduce the number of states when compared to DFAs, and upper and lower bounds for the trade-off when converting DFAs are studied.
Abstract: We investigate a restricted one-way cellular automaton (OCA) model where the number of cells is bounded by a constant number k, so-called kC-OCAs. In contrast to the general model, the generative capacity of the restricted model is reduced to the set of regular languages. A kC-OCA can be algorithmically converted to a deterministic finite automaton (DFA). The blow-up in the number of states is bounded by a polynomial of degree k. We can exhibit a family of unary languages which shows that this upper bound is tight in order of magnitude. We then study upper and lower bounds for the trade-off when converting DFAs to kC-OCAs. We show that there are regular languages where the use of kC-OCAs cannot reduce the number of states when compared to DFAs. We then investigate trade-offs between kC-OCAs with different numbers of cells and finally treat the problem of minimizing a given kC-OCA.
TL;DR: It is shown that if a regular language L is accepted by a Las Vegas automaton having r states such that the probability for a definite answer to occur is at least p, then r ≥ np, where n is the number of the states of the minimal deterministic automaton accepting L.
Abstract: We show that the size of a Las Vegas automaton and the size of a complete, minimal deterministic automaton accepting a regular language are polynomially related. More precisely, we show that if a regular language L is accepted by a Las Vegas automaton having r states such that the probability for a definite answer to occur is at least p , then r ≥ np , where n is the number of the states of the minimal deterministic automaton accepting L . Earlier this result has been obtained in [2] by using a reduction to one-way Las Vegas communication protocols , but here we give a direct proof based on information theory.
Journal Article•
TL;DR: It is proved that the size of the subsequence automaton for a set of k strings of length n is Ω(n k ) for any k≥ 1, which solves an open problem posed by Crochemore and Tronicek in 1999.
Abstract: Given a set of strings, the subsequence automaton accepts all subsequences of these strings. We will derive a lower bound for the maximum number of states of this automaton. We will prove that the size of the subsequence automaton for a set of k strings of length n is Ω(n k ) for any k > 1. It solves an open problem posed by Crochemore and Tronicek [2] in 1999, in which only the case k < 2 was shown.
01 Feb 2003
TL;DR: A decision procedure for LTL over Mazurkiewicz traces is exhibited that generalises the classical automata-theoretic approach to a LTL interpreted no longer over sequences but certain partial orders and applies a notion of independence-rewriting to formulas of the logic.
Abstract: Linear temporal logic (LTL) has become a well established tool for specifying the dynamic behaviour of reactive systems with an interleaving semantics, and the automata-theoretic 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 further on-the-fly model checking procedures. In this paper, we exhibit a decision procedure for LTL over Mazurkiewicz traces that generalises the classical automata-theoretic approach to a LTL interpreted no longer over sequences but certain partial orders. Specifically, we construct a (linear) alternating Buchi automaton (ABA) accepting the set of linearisations of traces satisfying the formula at hand. The salient point of our technique is to apply a notion of independence-rewriting to formulas of the logic. Furthermore, we show that the class of linear and trace-consistent ABA corresponds exactly to LTL formulas over Mazurkiewicz traces, lifting a similar result from Loding and Thomas formulated in the framework of LTL over words.
16 Jul 2003
TL;DR: It is shown that the ZPC structure can be built in linear time in the size of the expression and that the associated position automaton can be deduced from it in quadratic time.
Abstract: In this article we generalize the concepts of position automaton and ZPC structure to the regular K-expressions. We show that the ZPC structure can be built in linear time in the size of the expression and that the associated position automaton can be deduced from it in quadratic time.
TL;DR: A method to decompose this a kind of weakly invertible finite automata with delay 2 is presented.
Abstract: Some properties of a finite automaton composed of two weakly invertible finite automata with delay 1 are given, where each of those two automata has the output set of each state with the same size. And for a weakly invertible finite automaton M with delay 2 satisfying the properties mentioned in this paper, two weakly invertible finite automata with delay 1 are constructed such that M is equivalent to a sub-finite-automaton of the composition of those two. So a method to decompose this a kind of weakly invertible finite automata with delay 2 is presented.
Patent•
AT&T1
TL;DR: In this paper, a potential for each state of an input automaton to a set of destination states of a weighted automaton is first determined, and then the N-best paths are found in the result of an on-the-fly determinization of the input automata.
Abstract: Systems and methods for identifying the N-best strings of a weighted automaton. A potential for each state of an input automaton to a set of destination states of the input automaton is first determined. Then, the N-best paths are found in the result of an on-the-fly determinization of the input automaton. Only the portion of the input automaton needed to identify the N-best paths is determinized. As the input automaton is determinized, a potential for each new state of the partially determinized automaton is determined and is used in identifying the N-best paths of the determinized automaton, which correspond exactly to the N-best strings of the input automaton.
Journal Article•
TL;DR: In this article, it is shown that it is decidable in an effective way whether a series that is recognized by a finitely ambiguous max-plus automaton is sequential, and a collection of examples is given to illustrate the hierarchy of maxplus series with respect to ambiguity.
Abstract: Finite automata with weights in the max-plus semiring are considered. The main result is: it is decidable in an effective way whether a series that is recognized by a finitely ambiguous max-plus automaton is sequential. A collection of examples is given to illustrate the hierarchy of max-plus series with respect to ambiguity.
TL;DR: An alternative finite state machine is constructed which also accepts the language Untime (L T), but has fewer states than G′, which is shown for languages of both finite and infinite traces.
Abstract: Given a timed automaton G accepting the timed language LT a finite state machine G' can be constructed, known as the region automaton, which accepts the untimed language Untime (LT). In this paper we construct an alternative finite state machine which also accepts the language Untime (LT), but has fewer states than G'. This is shown for languages of both finite and infinite traces given that the time values in the time sequence increase strictly monotonically. The supervisory control design for timed automata, when the simplified untiming procedure is used and the time is strictly positive, is studied.
25 Aug 2003
TL;DR: This work introduces unambiguous automata where each accepted word is the label of exactly one accepting path and shows that each rational set of bi-infinite words is accepted by such an automaton.
Abstract: We consider finite automata accepting bi-infinite words. We introduce unambiguous automata where each accepted word is the label of exactly one accepting path. We show that each rational set of bi-infinite words is accepted by such an automaton. This result is a counterpart of McNaughton’s theorem for bi-infinite words.