25 research outputs found
An automaton over data words that captures EMSO logic
We develop a general framework for the specification and implementation of
systems whose executions are words, or partial orders, over an infinite
alphabet. As a model of an implementation, we introduce class register
automata, a one-way automata model over words with multiple data values. Our
model combines register automata and class memory automata. It has natural
interpretations. In particular, it captures communicating automata with an
unbounded number of processes, whose semantics can be described as a set of
(dynamic) message sequence charts. On the specification side, we provide a
local existential monadic second-order logic that does not impose any
restriction on the number of variables. We study the realizability problem and
show that every formula from that logic can be effectively, and in elementary
time, translated into an equivalent class register automaton
In the Maze of Data Languages
In data languages the positions of strings and trees carry a label from a
finite alphabet and a data value from an infinite alphabet. Extensions of
automata and logics over finite alphabets have been defined to recognize data
languages, both in the string and tree cases. In this paper we describe and
compare the complexity and expressiveness of such models to understand which
ones are better candidates as regular models
Characterizing Formality
Complexity classes are defined by quantitative restrictions of resources available to a computational model, like for instance the Turing machine.
Contrarily, there is no obvious commonality in the definition of families of formal languages - instead they are described by example.
This thesis is about the characterization of what makes a set of languages a family of formal languages.
Families of formal languages, like for example the regular, context-free languages and their sub-families exhibit properties that are contrasted by the ones of complexity classes.
Two of the properties families of formal languages seem to have is closure of intersection with regular languages, another is the existence of pumping or iteration arguments which yield the decidability of the emptiness.
Complexity classes do not generally have a decidable emptiness, which lead us to a first candidate for the notion of formality - the decidability of the emptiness of regular intersection (intreg).
We refute the decidability of intreg as a criterion by hiding the difficulty of deciding the emptiness of regular intersection:
We show that for every decidable language L there is a language L' of essentially the same complexity such that intreg(L') is decidable.
This implies that every complexity class contains complete languages for which the emptiness of regular intersection is decidable.
An intermediate result we show is that the set of true quantified Boolean formulae has a decidable emptiness of regular intersection.
As the known families of formal languages are all contained in NP, this yields a language (probably) outside of NP for which intreg is decidable, which additionally is a natural language in contrast to the artificial ones obtained by the hiding process.
We introduce the notion of protocol languages which capture in some sense the behavior of a data-structure underlying the model of a formal language.
They are defined in a fragment of second order logic, where the second order variables are uniquely determined by each word in the language and each letter implies a determined sub-structure of a word.
Viewing the letters of a word as vertices and the successor as edges between them, each word can be seen as a path.
The binary second order variables can be viewed as additional edges between word positions.
Therefore, each word in a protocol language defines some unique graph.
These graphs can be recognized by covering them with a predefined set of tiles which are node and edge-labeld graphs.
Additional numerical constraints on the amount of each tile-type yields shrinking-arguments for protocol languages.
If a word w in a protocol language exceeds a certain length such that the numerical constraints are (over-)satisfied, one can constuctively generate a shorter word w' from w that is also contained in the protocol language.
We define logical extensions of protocol languages by allowing the conjunction of additional first order or monadic second order definable formulae and analyze the extensions in regard to trio operations.
Protocol languages for the regular, context-free and indexed languages are exhibited -- for the first two we give protocol languages which act as generators for the respective family of formal languages.
Finally, we show that the emptiness of protocol languages is decidable
A Class of Automata for the Verification of Infinite, Resource-Allocating Behaviours
Process calculi for service-oriented computing often feature generation of fresh resources. So-called nominal automata have been studied both as semantic models for such calculi, and as acceptors of languages of finite words over infinite alphabets. In this paper we investi-gate nominal automata that accept infinite words. These automata are a generalisation of deterministic Muller automata to the setting of nominal sets. We prove decidability of complement, union, intersection, emptiness and equivalence, and determinacy by ultimately periodic words. The key to obtain such results is to use finite representations of the (otherwise infinite-state) defined class of automata. The definition of such operations enables model checking of process calculi featuring infinite behaviours, and resource allocation, to be implemented using classical automata-theoretic methods
Feasible Automata for Two-Variable Logic with Successor on Data Words
We introduce an automata model for data words, that is words that carry at
each position a symbol from a finite alphabet and a value from an unbounded
data domain. The model is (semantically) a restriction of data automata,
introduced by Bojanczyk, et. al. in 2006, therefore it is called weak data
automata. It is strictly less expressive than data automata and the expressive
power is incomparable with register automata. The expressive power of weak data
automata corresponds exactly to existential monadic second order logic with
successor +1 and data value equality \sim, EMSO2(+1,\sim). It follows from
previous work, David, et. al. in 2010, that the nonemptiness problem for weak
data automata can be decided in 2-NEXPTIME. Furthermore, we study weak B\"uchi
automata on data omega-strings. They can be characterized by the extension of
EMSO2(+1,\sim) with existential quantifiers for infinite sets. Finally, the
same complexity bound for its nonemptiness problem is established by a
nondeterministic polynomial time reduction to the nonemptiness problem of weak
data automata.Comment: 21 page
Weighted Logics for Nested Words and Algebraic Formal Power Series
Nested words, a model for recursive programs proposed by Alur and Madhusudan,
have recently gained much interest. In this paper we introduce quantitative
extensions and study nested word series which assign to nested words elements
of a semiring. We show that regular nested word series coincide with series
definable in weighted logics as introduced by Droste and Gastin. For this we
establish a connection between nested words and the free bisemigroup. Applying
our result, we obtain characterizations of algebraic formal power series in
terms of weighted logics. This generalizes results of Lautemann, Schwentick and
Therien on context-free languages
Automata and Logics for Concurrent Systems: Realizability and Verification
Automata are a popular tool to make computer systems accessible to formal methods. While classical finite automata are suitable to model sequential boolean programs, models of concurrent systems involve several interacting processes and extend finite-state machines in various respects. This habilitation thesis surveys several such extensions, including pushdown automata with multiple stacks, communicating automata with fixed, parameterized, or dynamic communication topology, and automata running on words over infinite alphabets. We focus on two major questions of classical automata theory, namely realizability (asking whether a specification has an automata counterpart) and model checking (asking whether a given automaton satisfies its specification)
FO2(<,+1,~) on data trees, data tree automata and branching vector addition systems
A data tree is an unranked ordered tree where each node carries a label from
a finite alphabet and a datum from some infinite domain. We consider the two
variable first order logic FO2(<,+1,~) over data trees. Here +1 refers to the
child and the next sibling relations while < refers to the descendant and
following sibling relations. Moreover, ~ is a binary predicate testing data
equality. We exhibit an automata model, denoted DAD# that is more expressive
than FO2(<,+1,~) but such that emptiness of DAD# and satisfiability of
FO2(<,+1,~) are inter-reducible. This is proved via a model of counter tree
automata, denoted EBVASS, that extends Branching Vector Addition Systems with
States (BVASS) with extra features for merging counters. We show that, as
decision problems, reachability for EBVASS, satisfiability of FO2(<,+1,~) and
emptiness of DAD# are equivalent