Logics for XML

This thesis describes the theoretical and practical foundations of a system for the static analysis of XML processing languages. The system relies on a fixpoint temporal logic with converse, derived from the mu-calculus, where models are finite trees. This calculus is expressive enough to capture regular tree types along with multi-directional navigation in trees, while having a single exponential time complexity. Specifically the decidability of the logic is proved in time 2^O(n) where n is the size of the input formula. Major XML concepts are linearly translated into the logic: XPath navigation and node selection semantics, and regular tree languages (which include DTDs and XML Schemas). Based on these embeddings, several problems of major importance in XML applications are reduced to satisfiability of the logic. These problems include XPath containment, emptiness, equivalence, overlap, coverage, in the presence or absence of regular tree type constraints, and the static type-checking of an annotated query. The focus is then given to a sound and complete algorithm for deciding the logic, along with a detailed complexity analysis, and crucial implementation techniques for building an effective solver. Practical experiments using a full implementation of the system are presented. The system appears to be efficient in practice for several realistic scenarios. The main application of this work is a new class of static analyzers for programming languages using both XPath expressions and XML type annotations (input and output). Such analyzers allow to ensure at compile-time valuable properties such as type-safety and optimizations, for safer and more efficient XML processing.

💡 Research Summary

The dissertation “Logics for XML” presents a comprehensive theoretical and practical framework for the static analysis of XML processing languages. Its central contribution is a fixpoint temporal logic with converse, derived from the modal μ‑calculus, whose models are finite trees. This logic is expressive enough to capture regular tree types (including DTDs and XML Schemas) and to encode multi‑directional navigation as found in XPath, while retaining a decision procedure that runs in single‑exponential time, specifically 2^O(n) where n is the size of the input formula.

The work begins by reviewing the foundations of XML processing: unranked trees, hedge representations, regular tree automata, and the syntax and denotational semantics of XPath. It then surveys existing logical formalisms—first‑order logic, monadic second‑order logic (MSO), WS2S, and various temporal logics—highlighting their relative expressiveness and computational costs. This sets the stage for the introduction of two complementary logical encodings of XML concepts.

First, XPath expressions are translated directly into WS2S (the weak monadic second‑order theory of two successors). Each XPath axis (child, parent, descendant, following‑sibling, etc.) becomes a binary relation between node variables, and predicates are expressed as WS2S formulas. The translation is linear in the size of the XPath expression, and the resulting WS2S formulas can be fed to the MONA tool to generate tree automata. The author demonstrates that this approach yields manageable intermediate automata even for complex queries, and provides a detailed complexity analysis showing that the translation does not increase the overall exponential bound.

Second, the dissertation introduces a bespoke fixpoint logic, a converse‑enhanced μ‑calculus tailored to XML trees. This logic supports forward and backward navigation, recursion via least and greatest fixpoints, and can embed regular tree type constraints as additional formulas. XPath navigation steps, qualifiers, and full path expressions are systematically encoded as μ‑calculus formulas; regular tree languages are encoded using automata‑based translations that preserve linear size. The author proves soundness and completeness of these embeddings and shows that the satisfiability problem for the logic remains in 2^O(n) time, matching the known optimal bound for MSO on trees.

A major part of the thesis is devoted to a concrete satisfiability‑testing algorithm for the new logic. The algorithm proceeds in three phases: (1) preprocessing to convert formulas into a cycle‑free normal form; (2) a fixpoint computation over sets of ψ‑types, where each ψ‑type represents a possible truth assignment to sub‑formulas at a node. Sets of ψ‑types are represented implicitly using Binary Decision Diagrams (BDDs), enabling efficient Boolean operations and early quantification to prune the search space. (3) Reconstruction of a concrete tree model from a satisfying assignment, allowing the tool to output an example XML document that witnesses the formula’s truth. Implementation techniques such as implicit set representation, conjunctive partitioning, and careful BDD variable ordering are described in depth.

The prototype solver is evaluated on a broad benchmark suite. Experiments include queries from the XPathMark benchmark, real‑world XPath expressions extracted from research papers, and queries that involve horizontal navigation (e.g., following‑sibling) as well as vertical navigation (e.g., ancestor). The solver is tested both with and without accompanying DTD or XML Schema constraints. Results show that, despite the worst‑case exponential complexity, the tool solves most practical instances within a few seconds, and scales reasonably when the size of the XPath expression or the depth of the tree increases. The experiments also reveal that the inclusion of regular tree type constraints adds only modest overhead, confirming the efficiency of the linear‑size translations.

In the concluding chapters, the author summarizes the contributions: (i) a unified logical framework that captures both XML schemas and XPath navigation; (ii) a decision procedure with provable single‑exponential complexity; (iii) a working implementation that demonstrates practical feasibility. Future work is outlined, including further BDD variable‑ordering heuristics, extending the logic to handle attributes and data values, integrating the solver into query optimizers, and applying the approach to static analysis of XML transformations (e.g., XSLT). The dissertation positions this logic‑based methodology as a solid foundation for building static analyzers that can guarantee type‑safety, enable compile‑time optimizations, and improve the reliability of XML‑intensive software systems.