We present an algorithm to solve XPath decision problems under regular tree type constraints and show its use to statically type-check XPath queries. To this end, we prove the decidability of a logic with converse for finite ordered trees whose time complexity is a simple exponential of the size of a formula. The logic corresponds to the alternation free modal µ-calculus without greatest fixpoint, restricted to finite trees, and where formulas are cycle-free. Our proof method is based on two auxiliary results. First, XML regular tree types and XPath expressions have a linear translation to cycle-free formulas. Second, the least and greatest fixpoints are equivalent for finite trees, hence the logic is closed under negation. Building on these results, we describe a practical, effective system for solving the satisfiability of a formula. The system has been experimented with some decision problems such as XPath emptiness, containment, overlap, and coverage, with or without type constraints. The benefit of the approach is that our system can be effectively used in static analyzers for programming languages

f on valid inputs conform to theoutput type? Since XML types are intrinsically more complex than the types found in

Abstract. Macro tree transducers (mtt) are an important model that both covers many useful XML transformations and allows decidable exact typechecking. This paper reports our first step toward an implementation of mtt typechecker that has a practical efficiency. Our approach is to represent an input type obtained from a backward inference as an alternating tree automaton, in a style similar to Tozawa’s XSLT0 typechecking. In this approach, typechecking reduces to checking emptiness of an alternating tree automaton. We propose several optimizations (Cartesian factorization, state partitioning) on the backward inference process in order to produce much smaller alternating tree automata than the naive algorithm, and we present our efficient algorithm for checking emptiness of alternating tree automata, where we exploit the explicit representation of alternation for local optimizations. Our preliminary experiments confirm that our algorithm has a practical performance that can typecheck simple transformations with respect to the full XHTML in a reasonable time. 1

XACT is an extension of Java for making type-safe XML transfor-mations. Unlike other approaches, XACT provides a programming model based on XML templates and XPath together with a typechecker based on data-flow analysis. We show how to extend the data-flow analysis technique used inthe XACT system to support XML Schema as type formalism. The technique is able to model advanced features, such as type deriva-tions and overloaded local element declarations, and also datatypes of attribute values and character data. Moreover, we introduce op-tional type annotations to improve modularity of the type checking.

We propose a tree logic capable of expressing simple cardinality constraints on the number of nodes selected by an arbitrarily deep regular path with backward navigation. Specifically, a sublogic of the alternation-free µ−calculus with converse for finite trees is extended with a counting operator in order to reason on the cardinality of node sets. Also, we developed a bottom-up tableau-based satisfiability-checking algorithm, which resulted to have the same complexity than the logic without the counting operator: a simple exponential in the size of a formula. This result can be seen as an extension of the so-called graded-modalities introduced in [18], which allows counting constraints only on immediate successors, with conditions on the number of nodes accessible by an arbitrary recursive and multidirectional path. This work generalizes the optimal complexity bound: 2 O(n) where n is the length of the formula, shown in [11], for satisfiability of the logic extended with such counting constraints. Finally, we identify a decidable XPath fragment featuring cardinality constraints on paths with upward/downward recursive navigation, in the presence of XML types. 1.

XML graphs have shown to be a simple and effective formalism for representing sets of XML documents in program analysis. It has evolved through a six year period with variants tailored for a range of applications. We present a unified definition, outline the key properties including validation of XML graphs against different XML schema languages, and provide a software package that enables others to make use of these ideas. We also survey the use of XML graphs for program analysis with four very different languages: Xact (XML in Java), Java Servlets (Web application programming), XSugar (transformations between XML and non-XML data), and XSLT (stylesheets for transforming XML documents). 1.

1.1 Documents, Schemas, and Schema Languages........... 7

Database systems often use XML schema to describe the format of valid XML documents. Usually, this format is determined when the system is designed. Sometimes, in an already functioning system, a need arises to change the XML schemas. In such a situation, the system has to transform the old XML documents so that they conform to the new format and that as little information as possible is lost in the process. This process is called schema evolution. We have implemented an XML schema transformation toolkit within IBM Master Data Management Server (MDM). MDM uses XML documents to describe products that an enterprise may be offering to its clients. In this work we focus on evolving schemas rather than on integrating separate or heterogeneous data sources. Our solution includes an extendible schema matching algorithm that was designed with evolving XML schemas in mind and takes advantage of hierarchical structure of XML. It also includes a data transformation and migration method appropriate for environments where migration is performed in an abstraction layer above the DBMS. Finally, we describe a novel way of extending an XSLT editor with an XSLT visualization feature to allow the user’s input and evaluation of the transformation. 1.

It is worth noticing that one of the main difficulty in XPath decision problems is the consideration of a possibly infinite quantification over a set of trees. Among the features also affecting the difficulty of such problems we find the presence of XML types [3, 11], the combination of downward and updown navigation with recursion in trees [25, 3, 11], comparison of data values of infinite domain [3, 15], and cardinality constraints on node sets [6, 22]. It is already known that the consideration of the whole set, as well as some subsets, of such features leads to undecidability [21, 3]. Numerical coninria-00358797,

In general, typechecking refers to the problem where, given a program P, an input type σ, and an output type τ, one must decide whether P is type-safe, that is, whether it produces only outputs of type τ when run on inputs of type σ. In the XML context, typechecking problems mainly arise in two forms: •XML-to-XML transformations, where P transforms XML documents conforming to a given type into XML documents conforming to another given type; and •XML publishing, where P transforms relational databases into XML views of these databases and it is necessary to check that all generated views conform to a specified type. A type for XML documents is typically a regular tree language, usually expressed as a schema written in a schema language such as DTD, XML Schema, or a Relax NG (see XML Types). In the XML publishing case, the input type σ is a relational database schema, possibly with integrity constraints. Typechecking problems may or may not be decidable, depending on (1) the class of programs considered, (2) the class of input types (relational schemas, DTDs, XML Schemas, Relax NG schema, or perhaps other subclasses of the regular tree languages), and (3) the class of output types. In cases where it is decidable, typechecking can be done exactly. In cases where it is undecidable, one must revert to approximate or incomplete typecheckers that may return false negatives—i.e., may reject a program even if it is type-safe. Even when exact typechecking