Ω-regular Languages Research Articles

Semantic Flowers for Good-for-Games and Deterministic Automata

We present an innovative approach for capturing the complexity of ω-regular languages using the concept of flowers. This semantic tool combines two syntax-based definitions, namely the Mostowski hierarchy of word languages and syntactic flowers. The former is based on deterministic parity automata with a limited number of priorities, while the latter simplifies deterministic parity automata by reducing the number of priorities used, without altering their structure. Synthesising these two approaches yields a semantic concept of flowers, which offers a more effective way of dealing with the complexity of ω-regular languages. This letter provides a comprehensive definition of semantic flowers and shows that it captures the complexity of ω-regular languages. We also show that this natural concept yields simple proofs of the expressive power of good-for-games automata.

An interval temporal logic characterization of extended ω-regular languages

Some extensions of ω-regular languages have been proposed in the literature to express asymptotic properties of ω-words which are not captured by ω-regular languages. They include ωB-regular languages, that extend ω-regular languages with boundedness, ωS-regular languages, that enrich ω-regular ones with strong unboundedness, ωBS-regular languages, that combine ωB- and ωS-regular ones, and ωT-regular languages, that include meaningful languages which are not ωBS-regular. Formal definitions of extended ω-regular languages have been given in terms of both suitable classes of automata and extended ω-regular expressions, while satisfactory temporal logic counterparts are still missing. In this paper, we give a characterization of them in terms of interval temporal logics by providing an explicit encoding of expressions into formulas.

Balanced-by-Construction Regular and ω-Regular Languages

Parenn is the typical generalization of the Dyck language to multiple types of parentheses. We generalize its notion of balancedness to allow parentheses of different types to freely commute. We show that balanced regular and [Formula: see text]-regular languages can be characterized by syntactic constraints on regular and [Formula: see text]-regular expressions and, using the shuffle on trajectories operator, we define grammars for balanced-by-construction expressions with which one can express every balanced regular and [Formula: see text]-regular language.

Learning infinite-word automata with loop-index queries

We propose a new framework for active learning of deterministic infinite-words automata. In our framework, the teacher answers standard membership and equivalence queries, and additionally it provides the loop index of the target automaton on wvω, which is the minimal number of letters of wvω past which the target automaton reaches the final cycle on wvω. We argue that in potential applications if one can answer Boolean part in membership (and equivalence) queries, one can compute the loop index as well.Our framework is an extension of Angluin's L⁎-algorithm with the crucial difference that the queries about the loop index depend on a particular automaton representing an ω-regular language. This allows us to bypass the NP-hardness coming from the minimisation problem for deterministic Büchi automata and provide a polynomial-time algorithm for learning deterministic weighted automata with ▪ value function. The algorithm can be easily adjusted for deterministic automata with ▪ value function and deterministic Büchi automata. Finally, deterministic parity automata, which recognize all ω-regular languages, can be considered as deterministic automata with ▪ value function and hence they can be learned in our framework.

Beyond ω-regular languages: ωT-regular expressions and their automata and logic counterparts

In the last years, some extensions of ω-regular languages, namely, ωB-regular (ω-regular languages extended with boundedness), ωS-regular (ω-regular languages extended with strong unboundedness), and ωBS-regular languages (the combination of ωB- and ωS-regular ones), have been proposed in the literature. While the first two classes satisfy a generalized closure property, which states that the complement of an ωB-regular (resp., ωS-regular) language is an ωS-regular (resp., ωB-regular) one, the last class is not closed under complementation. The existence of non-ωBS-regular languages that are the complements of some ωBS-regular ones and express fairly natural asymptotic behaviors motivates the search for other significant classes of extended ω-regular languages. In this paper, we present the class of ωT-regular languages, which includes meaningful languages that are not ωBS-regular. We define this new class of languages in terms of ωT-regular expressions. Then, we introduce a new class of automata (counter-check automata) and we prove that (i) their emptiness problem is decidable in PTIME, and (ii) they are expressive enough to capture ωT-regular languages. We also provide an encoding of ωT-regular expressions into S1S+U. Finally, we investigate a stronger variant of ωT-regular languages (ωTs-regular languages). We characterize the resulting class of languages in terms of ωTs-regular expressions, and we show how to map it into a suitable class of automata, called counter-queue automata. We conclude the paper with a comparison of the expressiveness of ωT- and ωTs-regular languages and of the corresponding automata.

On the initialization of clocks in timed formalisms

Constraint LTL over clocks (CLTLoc) is an extension of LTL allowing for atomic formulae of the form x<c or x=c, which constrain the time delay measured by clock x with respect to constant value c. In a previous work, we showed that CLTLoc is equivalent to Timed Automata. The result was proven by considering a clock semantics that conforms to the original definition by Alur and Dill, i.e., when clocks are reset (i.e., equal to 0) in the origin, both CLTLoc and Timed Automata define the class of Timed ω-Regular languages. In this paper, we show that if we allow the clocks to have any value in the origin, the power of the formalism to express timed languages does not change, as long as non-Zeno languages are considered. If Zeno languages are allowed, then CLTLoc is strictly more powerful than TA. As a consequence of these results, we also show that non-Zeno Timed ω-Regular languages are closed with respect to the left quotient operation with timed regular languages over finite words.

The complexity of weakly recognizing morphisms

Weakly recognizing morphisms from free semigroups onto finite semigroups are a classical way for defining the class of ω-regular languages, i.e., a set of infinite words is weakly recognizable by such a morphism if and only if it is accepted by some Büchi automaton. We study the descriptional complexity of various constructions and the computational complexity of various decision problems for weakly recognizing morphisms. The constructions we consider are the conversion from and to Büchi automata, the conversion into strongly recognizing morphisms, as well as complementation. We also show that the fixed membership problem is NC1-complete, the general membership problem is in L and that the inclusion, equivalence and universality problems are NL-complete. The emptiness problem is shown to be NL-complete if the input is given as a non-surjective morphism.

Fuzzy alternating Büchi automata over distributive lattices

Alternation was first proposed by Chandra et al. for obtaining a theoretical model of parallel computations. Compared with nondeterminism, alternation gives computing devices the power of universal choice in addition to existential choice. In this paper, we put forward a notion of fuzzy alternating Büchi automata over a distributive lattice L (L-ABAs, for short). In our setting, a weight is the label of a leaf node of the run tree when executing a transition, which is helpful in complementing L-ABAs. Taking the dual operation on the transition function and negating final costs on states, we can get the complement of a given L-ABA. We point out that L-ABAs have the same expressive power as L-valued fuzzy nondeterministic Büchi automata (L-NBAs). A construction presented here shows that languages accepted by L-valued fuzzy alternating co-Büchi automata (L-ACAs) are also ω-regular languages. Moreover, closure properties of L-ABAs and decision problems for L-ABAs are also discussed.

What is decidable about partially observable Markov decision processes with ω-regular objectives

We consider partially observable Markov decision processes (POMDPs) with ω-regular conditions specified as parity objectives. The class of ω-regular languages provides a robust specification language to express properties in verification, and parity objectives are canonical forms to express them. The qualitative analysis problem given a POMDP and a parity objective asks whether there is a strategy to ensure that the objective is satisfied with probability 1 (resp. positive probability). While the qualitative analysis problems are undecidable even for special cases of parity objectives, we establish decidability (with optimal complexity) for POMDPs with all parity objectives under finite-memory strategies. We establish optimal (exponential) memory bounds and EXPTIME-completeness of the qualitative analysis problems under finite-memory strategies for POMDPs with parity objectives. We also present a practical approach, where we design heuristics to deal with the exponential complexity, and have applied our implementation on a number of POMDP examples.

Topology, monitorable properties and runtime verification

We review concepts like safety, liveness, and monitorability from a rigorous topological viewpoint. Thus, monitorability of an ω-language means that the boundary in the Cantor topology has an empty interior. We show that all ω-regular languages which are deterministic and co-deterministic are monitorable, but certain deterministic liveness properties like “infinitely many a's” cannot be written as a countable union of monitorable languages. We briefly discuss model checking with LTL, its three-valued variant LTL3 and monitor constructions based upon LTL3.

K-counting automata

In this paper, we define k-counting automata as recognizers for ω-languages, i.e. languages of infinite words. We prove that the class of ω-languages they recognize is a proper extension of the ω-regular languages. In addition we prove that languages recognized by k-counting automata are closed under Boolean operations. It remains an open problem whether or not emptiness is decidable for k-counting automata. However, we conjecture strongly that it is decidable and give formal reasons why we believe so.

Safety first: a two-stage algorithm for the synthesis of reactive systems

In the game-theoretic approach to the synthesis of reactive systems, specifications are often expressed as ω-regular languages. Computing a winning strategy to an infinite game whose winning condition is an ω-regular language is then the main step in obtaining an implementation. Conjoining all the properties of a specification to obtain a monolithic game suffers from the doubly exponential determinization that is required. Despite the success of symbolic algorithms, the monolithic approach is not practical. Existing techniques achieve efficiency by imposing restrictions on the ω-regular languages they deal with. In contrast, we present an approach that achieves improvement in performance through the decomposition of the problem while still accepting the full set of ω-regular languages. Each property is translated into a deterministic ω-regular automaton explicitly while the two-player game defined by the collection of automata is played symbolically. Safety and persistence properties usually make up the majority of a specification. We take advantage of this by solving the game incrementally. Each safety and persistence property is used to gradually construct the parity game. Optimizations are applied after each refinement of the graph. This process produces a compact symbolic encoding of the parity game. We then compose the remaining properties and solve one final game after possibly solving smaller games to further optimize the graph. An implementation is finally derived from the winning strategies computed. We compare the results of our tool to those of the synthesis tool Anzu.

Abstractions of hybrid systems: formal languages to describe dynamical behaviour

AbstractWe show how finite-state automata over finite and infinite words can capture key dynamical properties of hybrid systems. The purpose is to obtain a discrete abstraction of the main complex dynamical behaviour patterns that such systems exhibit. We will form a labelled transition system as an abstraction of the hybrid system, and, in order to differentiate between the key dynamical behaviours, we will associate a set of formal languages to each of the behaviours. We will use both finite regular and infinite ω-regular languages. These formal languages can be accepted by a generalised Muller automaton, which is a novel approach in the specification of dynamical properties of hybrid systems.

Weak MSO with the Unbounding Quantifier

A new class of languages of infinite words is introduced, called the max-regular languages, extending the class of ω-regular languages. The class has two equivalent descriptions: in terms of automata (a type of deterministic counter automaton), and in terms of logic (weak monadic second-order logic with a bounding quantifier). Effective translations between the logic and automata are given.

Transformations of logic programs on infinite lists

AbstractWe consider an extension of logic programs, called ω-programs, that can be used to define predicates overinfinite lists. ω-programs allow us to specify properties of the infinite behavior of reactive systems and, in general, properties of infinite sequences of events. The semantics of ω-programs is an extension of the perfect model semantics. We present variants of the familiar unfold/fold rules which can be used for transforming ω-programs. We show that these new rules are correct, that is, their application preserves the perfect model semantics. Then we outline a general methodology based on program transformation for verifying properties of ω-programs. We demonstrate the power of our transformation-based verification methodology by proving some properties of Büchi automata and ω-regular languages.

On the Borel Complexity of MSO Definable Sets of Branches

An infinite binaryword can be identified with a branch in the full binary tree. We consider sets of branches definable in monadic second-order logic over the tree, where we allow some extra monadic predicates on the nodes. We show that this class equals to the Boolean combinations of sets in the Borel class Σ $^0_2$ over the Cantor discontinuum. Note that the last coincides with the Borel complexity of ω-regular languages.

Bounded Model Checking for All Regular Properties

The technique of bounded model checking is extended to the linear time μ-calculus, a temporal logic that can express all monadic second-order properties of ω-words, in other words, all ω-regular languages. Experimental evidence is presented showing that the method can be successfully employed for properties that are hard or impossible to express in the weaker logic LTL that is traditionally used in bounded model checking.

Formula omitted]-Regular languages are testable with a constant number of queries

We continue the study of combinatorial property testing. For a property ψ, an ɛ-test for ψ, for 0<ɛ⩽1, is a randomized algorithm that given an input x, returns “yes’’ if x satisfies ψ, and returns “no’’ with high probability if x is ɛ-far from satisfying ψ, where ɛ-far essentially means that an ɛ-fraction of x needs to be changed in order for it to satisfy ψ. In (Proceedings of the 40th IEEE Symposium on Foundations of Computer Science, 1999, pp. 645–655), Alon et al. show that regular languages are ɛ-testable with a constant (depends on ψ and ɛ and independent of x) number of queries. We extend the result in (Proceedings of the 40th IEEE Symposium on Foundations of Computer Science, 1999, pp. 645–655) to ω-regular languages: given a nondeterministic Büchi automaton A on infinite words and a small ɛ>0, we describe an algorithm that gets as input an infinite lasso-shape word of the form x·yω, for finite words x and y, samples only a constant number of letters in x and y, returns “yes’’ if w∈L(A), and returns “no’’ with probability 23 if w is ɛ-far from L(A). We also discuss the applicability of property testing to formal verification, where ω-regular languages are used for the specification of the behavior of nonterminating reactive systems, and computations correspond to lasso-shape words.

Formal verification in hardware design

In recent years, formal methods have emerged as an alternative approach to ensuring the quality and correctness of hardware designs, overcoming some of the limitations of traditional validation techniques such as simulation and testing.There are two main aspects to the application of formal methods in a design process: the formal framework used to specify desired properties of a design and the verification techniques and tools used to reason about the relationship between a specification and a corresponding implementation. We survey a variety of frameworks and techniques proposed in the literature and applied to actual designs. The specification frameworks we describe include temporal logics, predicate logic, abstraction and refinement, as well as containment between ω-regular languages. The verification techniques presented include model checking, automata-theoretic techniques, automated theorem proving, and approaches that integrate the above methods.In order to provide insight into the scope and limitations of currently available techniques, we present a selection of case studies where formal methods were applied to industrial-scale designs, such as microprocessors, floating-point hardware, protocols, memory subsystems, and communications hardware.

Timing Diagrams: Formalization and Algorithmic Verification

Timing diagrams are popular in hardware design. They have been formalized for use in reasoning tasks, such as computer-aided verification. These efforts have largely treated timing diagrams as interfaces to established notations for which verification is decidable; this has restricted timing diagrams to expressing only regular language properties. This paper presents a timing diagram logic capable of expressing certain context-free and context-sensitive properties. It shows that verification is decidable for properties expressible in this logic. More specifically, it shows that containment of ω-regular languages generated by Buchi automata in timing diagram languages is decidable. The result relies on a correlation between timing diagram and reversal bounded counter machine languages.