Results 1  10
of
27
XPath, transitive closure logic, and nested tree walking automata
 In Proceedings PODS 2008
, 2008
"... 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 expressiv ..."
Abstract

Cited by 26 (0 self)
 Add to MetaCart
(Show Context)
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 treewalking 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 2ExpTimecomplete (it is ExpTimecomplete for Core XPath).
Reasoning about XML with Temporal Logics and Automata
 In LPAR’08
"... 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 ..."
Abstract

Cited by 25 (4 self)
 Add to MetaCart
(Show Context)
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 singleexponential translation into unranked tree automata, in the spirit of the classical LTLtoBüchi automata translation. Automata arising from this translation have a number of additional properties; in particular, they are convenient for reasoning about unary nodeselecting 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.
Temporal logics for concurrent recursive programs: Satisfiability and model checking
 In MFCS’11, volume 6907 of LNCS
, 2011
"... Abstract. We develop a general framework for the design of temporal logics for concurrent recursive programs. A program execution is modeled as a partial order with multiple nesting relations. To specify properties of executions, we consider any temporal logic whose modalities aredefinable in monadi ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We develop a general framework for the design of temporal logics for concurrent recursive programs. A program execution is modeled as a partial order with multiple nesting relations. To specify properties of executions, we consider any temporal logic whose modalities aredefinable in monadic secondorder logic and that, in addition, allows PDLlike path expressions. This captures, in a unifying framework, a wide range of logics defined for ranked and unranked trees, nested words, and Mazurkiewicz traces that have been studied separately. We show that satisfiability and model checking are decidable in EXPTIME and 2EXPTIME, depending on the precise path modalities. 1
Reducing Behavioural to Structural Properties of Programs with Procedures
"... Abstract There is an intimate link between program structure and behaviour. Exploiting this link to phrase program correctness problems in terms of the structural properties of a program graph rather than in terms of its unfoldings is a useful strategy for making analyses more tractable. The present ..."
Abstract

Cited by 6 (6 self)
 Add to MetaCart
(Show Context)
Abstract There is an intimate link between program structure and behaviour. Exploiting this link to phrase program correctness problems in terms of the structural properties of a program graph rather than in terms of its unfoldings is a useful strategy for making analyses more tractable. The present paper presents a characterisation of behavioural program properties through sets of structural properties by means of a translation. The characterisation is given in the context of a program model based on control flow graphs of sequential programs with procedures, and properties expressed in a fragment of the modal µcalculus with boxes and greatest fixedpoints only. The property translation is based on a tableau construction that conceptually amounts to symbolic execution of the behavioural formula, collecting structural constraints along the way. By keeping track of the subformulae that have been examined, recursion in the structural constraints can be identified and captured by fixedpoint formulae. The tableau construction terminates, and the characterisation is exact, i.e. the translation is sound and complete. A prototype implementation has been developed. We discuss several applications of the characterisation, in particular sound and complete compositional verification for behavioural properties based on maximal models. 1
Regular Languages of Nested Words: Fixed Points, Automata, and Synchronization
"... Nested words provide a natural model of runs of programs with recursive procedure calls. The usual connection between monadic secondorder 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 wel ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
Nested words provide a natural model of runs of programs with recursive procedure calls. The usual connection between monadic secondorder 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 wellknown 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 mucalculus is as expressive as MSO over finite and infinite nested words, and the equivalence holds, more generally, for mucalculus 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 lettertoletter 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.
Temporal Reasoning for Procedural Programs
"... 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 languag ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
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 MannaPnuelistyle temporal reasoning with Hoarestyle reasoning about structured programs. Second, it allows verification of “nonregular” 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.
The complexity of modelchecking multistack systems
, 2012
"... Abstract—We consider the lineartime model checking problem for boolean concurrent programs with recursive procedure calls. While sequential recursive programs are usually modeled as pushdown automata, concurrent recursive programs involve several processes and can be naturally abstracted as pushdo ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Abstract—We consider the lineartime model checking problem for boolean concurrent programs with recursive procedure calls. While sequential recursive programs are usually modeled as pushdown automata, concurrent recursive programs involve several processes and can be naturally abstracted as pushdown automata with multiple stacks. Their behavior can be understood as words with multiple nesting relations, each relation connecting a procedure call with its corresponding return. To reason about multiply nested words, we consider the class of all temporal logics as defined in the book by Gabbay, Hodkinson, and Reynolds (1994). The unifying feature of these temporal logics is that their modalities are defined in monadic secondorder (MSO) logic. In particular, this captures numerous temporal logics over concurrent and/or recursive programs that have been defined so far. Since the general model checking problem is undecidable, we restrict attention to phase bounded executions as proposed by La Torre, Madhusudan, and Parlato (LICS 2007). While the MSO model checking problem in this case is nonelementary, our main result states that the model checking (and satisfiability) problem for all these temporal logics is decidable in elementary time. More precisely, it is solvable in (n + 2)EXPTIME where n is the maximal level of the MSO modalities in the monadic quantifier alternation hierarchy. We complement this result and provide, for each level n, a temporal logic whose model checking problem is nEXPSPACEhard. I.
Synthesizing Reactive Programs
"... 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 p ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
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
CVPP: A tool set for compositional verification of control–flow safety properties
 FOVEOOS 2010. LNCS
, 2011
"... This paper describes CVPP, a tool set for compositional verification of control–flow safety properties for programs with procedures. The compositional verification principle that underlies CVPP is based on maximal models constructed from component specifications. Maximal models replace the actual ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
This paper describes CVPP, a tool set for compositional verification of control–flow safety properties for programs with procedures. The compositional verification principle that underlies CVPP is based on maximal models constructed from component specifications. Maximal models replace the actual components when verifying the whole program, either for the purposes of modularity of verification or due to unavailability of the component implementations at verification time. A characteristic feature of the principle and the tool set is the distinction between program structure and behaviour. While behavioural properties are more abstract and convenient for specification purposes, structural ones are easier to manipulate, in particular when it comes to verification or the construction of maximal models. Therefore, CVPP also contains the means to characterise a given behavioural formula by a set of structural formulae. The paper presents the underlying framework for compositional verification and the components of the tool set. Several verification scenarios are described, as well as wrapper tools that support the automatic execution of such scenarios, providing appropriate pre – and post–processing to interface smoothly with the user and to encapsulate the inner workings of the tool set.
Concrete Semantics for Pushdown Analysis: The Essence of Summarization
"... Abstract. Pushdown analysis is better than finitestate analysis in precision and performance. Why then have we not seen total widespread adoption of these techniques? For one, the known techniques are technically burdened and difficult to understand or extend. Control structure of the programming l ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
Abstract. Pushdown analysis is better than finitestate analysis in precision and performance. Why then have we not seen total widespread adoption of these techniques? For one, the known techniques are technically burdened and difficult to understand or extend. Control structure of the programming language gets pulled into the model of computation, which makes extensions to nonpushdown control structures, such as call/cc or shift and reset, nontrivial. We show a derivational approach to abstract interpretation that yields transparently sound static analyses that can precisely match calls and returns when applied to wellknown abstract machines. We show that adding memoization and segmenting the continuation into bounded pieces leads to machines that abstract to static analyses for contextfree reachability by simply bounding the stores. This technique allows us to derive existing, more technically involved analyses, and a novel pushdown analysis for delimited, composable control. 1