We consider the navigational core of XPath, extended with two operators: the Kleene star for taking the transitive closure of path expressions, and a subtree relativisation operator, allowing one to restrict attention to a specific subtree while evaluating a subexpression. We show that the expressive power of this XPath dialect equals that of FO(MTC), first order logic extended with monadic transitive closure. We also give a characterization in terms of nested tree-walking automata. Using the latter we then proceed to show that the language is strictly less expressive than MSO. This solves an open question about the relative expressive power of FO(MTC) and MSO on trees. We also investigate the complexity for our XPath dialect. We show that query evaluation be done in polynomial time (combined complexity), but that satisfiability and query containment (as well as emptiness for our automaton model) are 2ExpTime-complete (it is ExpTime-complete for Core XPath).

We show that problems arising in static analysis of XML specifications and transformations can be dealt with using techniques similar to those developed for static analysis of programs. Many properties of interest in the XML context are related to navigation, and can be formulated in temporal logics for trees. We choose a logic that admits a simple single-exponential translation into unranked tree automata, in the spirit of the classical LTL-to-Büchi automata translation. Automata arising from this translation have a number of additional properties; in particular, they are convenient for reasoning about unary node-selecting queries, which are important in the XML context. We give two applications of such reasoning: one deals with a classical XML problem of reasoning about navigation in the presence of schemas, and the other relates to verifying security properties of XML views.

We argue that the classic Church’s synthesis problem and the subsequent research that is has spurred is really targeted towards synthesizing transition systems and not programs. We believe that the objective of synthesis must be programs; programs are compact and are the true aim in many synthesis problems, while the transition systems that correspond to them are often large and useless as synthesized artefacts. We reformulate the synthesis of reactive systems in terms of program synthesis, and develop a theory to show that the problem of synthesizing programs over a fixed set of Boolean variables in a simple imperative programming language is decidable for regular ω-specifications. We also present results for synthesizing programs with recursion against both regular specifications as well as visiblypushdown language specifications. Finally, we show applications to program repair, and conclude with open problems in synthesizing distributed programs. 1

Abstract. Nested words are a restriction of the class of visibly pushdown languages that provide a natural model of runs of programs with recursive procedure calls. The usual connection between monadic second-order logic (MSO) and automata extends from words to nested words and gives us a natural notion of regular languages of nested words. In this paper we look at some well-known aspects of regular languages – their characterization via fixed points, deterministic and alternating automata for them, and synchronization for defining regular relations – and extend them to nested words. We show that mu-calculus is as expressive as MSO over finite and infinite nested words, and the equivalence holds, more generally, for mu-calculus with past modalities evaluated in arbitrary positions in a word, not only in the first position. We introduce the notion of alternating automata for nested words, show that they are as expressive as the usual automata, and also prove that Muller automata can be determinized (unlike in the case of visibly pushdown languages). Finally we look at synchronization over nested words. We show that the usual letter-to-letter synchronization is completely incompatible with nested words (in the sense that even the weakest form of it leads to an undecidable formalism) and present an alternative form of synchronization that gives us decidable notions of regular relations. 1

We define and study an automata model of concurrent recursive programs. An automaton consists of a finite number of pushdown systems running in parallel and communicating via shared actions. Actually, we combine multi-stack visibly pushdown automata and Zielonka’s asynchronous automata towards a model with an undecidable emptiness problem. However, a reasonable restriction allows us to lift Zielonka’s Theorem to this recursive setting and permits a logical characterization in terms of a suitable monadic second-order logic. Building on results from Mazurkiewicz trace theory and recent work by La Torre, Madhusudan, and Parlato, we thus develop a framework for the specification, synthesis, and verification of concurrent recursive processes.

Abstract. While temporal verification of programs is a topic with a long history, its traditional basis—semantics based on word languages—is illsuited for modular reasoning about procedural programs. We address this issue by defining the semantics of procedural (potentially recursive) programs using languages of nested words and developing a framework for temporal reasoning around it. This generalization has two benefits. First, this style of reasoning naturally unifies Manna-Pnueli-style temporal reasoning with Hoare-style reasoning about structured programs. Second, it allows verification of “non-regular ” properties of specific procedural contexts—e.g., “If a lock is acquired in a context, then it is released in the same context. ” We present proof rules for a variety of properties such as local safety, local response, and staircase reactivity; our rules are sufficient to prove all temporal properties over nested words. We show that our rules are sound and relatively complete. 1

Abstract. We investigate the hybrid extension of CaRet, denoted HyCaRet, obtained by adding the standard existential binder operator ∃. We show that the one variable fragment 1-HyCaRet of HyCaRet is expressively complete for the firstorder logic FOµ which extends FO over words with a binary matching predicate. While all the known FOµ-complete and elementary extensions of CaRet can be linearly translated in 1-HyCaRet,1-HyCaRet can be exponentially more succinct than them. Moreover, the complexity of its satisfiability and pushdown modelchecking problems are 2EXPTIME-complete, which is the same complexity as that of two known FOµ-complete extensions of CaRet suitable for compositional and modular reasoning, namely CaRet + ‘within ’ and CaRet + ‘forgettable past’. Finally, we show that for each h ≥ 1, satisfiability and pushdown model-checking of the fragment HyCaRet h of HyCaRet consisting of formulas with nesting depth of ∃ at most h is exactly (h + 1)-EXPTIME-complete. 1