Logics for Unranked Trees: An Overview

Labeled unranked trees are used as a model of XML documents, and logical languages for them have been studied actively over the past several years. Such logics have different purposes: some are better suited for extracting data, some for expressing navigational properties, and some make it easy to relate complex properties of trees to the existence of tree automata for those properties. Furthermore, logics differ significantly in their model-checking properties, their automata models, and their behavior on ordered and unordered trees. In this paper we present a survey of logics for unranked trees.


Introduction
Trees arise everywhere in computer science, and there are numerous formalisms in the literature for describing and manipulating trees.Some of these formalisms are declarative and based on logical specifications: for example, first-order logic, monadic second-order logic, and various temporal and fixed-point logics over trees.Others are procedural formalisms such as various flavors of tree automata, or tree transducers, or tree grammars.All these formalisms have found numerous applications in verification, program analysis, logic programming, constraint programming, linguistics, and databases.
Until recently, most logical formalisms for trees dealt with ranked trees [CG+02,Tho97]: in such trees, all nodes have the same fixed number of children (or, a bit more generally, the number of children of a node is determined by the label of that node).Over the past several years, however, the focus has shifted towards unranked trees, in which there are no restrictions on the number of children a node can have.For example, the left tree in Figure 1 is a binary tree in which every non-leaf node has two children.In the second tree in Figure 1, however, different nodes have a different number of children.Although unranked trees have been considered in the 60s and 70s [PQ68,Tak75,Tha67], and are related to feature trees over an infinite set of features [Smo92] which are a particular kind of feature structures that have been investigated by computational linguists [Bla94,Car92,RK86], their systematic study was initiated by the development of XML (eXtensible Markup Language).XML is a data format which has become the lingua franca for information exchange on the World Wide Web.In particular, XML data is typically modeled as labeled unranked trees [Nev02,Via01].
This connection has led to a renewed interest in logical and procedural formalisms for unranked trees.Since XML trees are used to exchange data, the usual database query language paradigms apply: one uses logical formalisms for expressing declarative queries, and procedural formalisms for evaluating those declarative queries.Logics over unranked trees defining a variety of query languages for them appeared in large numbers over the past 7-8 years, and they come in many flavors and shapes.What is common to them, however, is a close connection to automata models, and quite often to temporal and modal logics, especially when one describes properties of paths through a document.
Let us now review some of the parameters according to which logics for unranked trees can be classified.
The yardstick logic: Most formalisms are "inspired" by one of the two logics often used in the context of trees: first-order logic (FO), and monadic second-order logic (MSO) that extends FO by quantification over sets of nodes.Query languages and schema formalisms for XML tend to use MSO as the yardstick: for example, XML Document Type Definition (DTDs, or, more precisely, XSD -XML Schema Definition) are essentially equivalent to MSO sentences, and various languages for extraction of data from XML documents, although being syntactically very different, have the power of MSO unary queries.On the other hand, navigational aspects of XML, in particular, logics capturing various fragments of XPath, are usually closely related to FO and its fragments.Arity of queries: Most commonly one considers Boolean or unary queries.Boolean queries are logical sentences and thus evaluate to true or false.For example, checking if an XML document conforms to a schema specification is represented by a Boolean query.Unary queries correspond to formulae in one free variable, and thus produce a set of nodes.For example, extracting sets of nodes, or evaluating XPath expressions relative to the root naturally give rise to unary queries.Complexity of model-checking/query-evaluation: The model-checking problem asks whether a tree T satisfies a logical sentence ϕ, written T |= ϕ.If ϕ is an MSO sentence ϕ, it can be evaluated in linear time in the size of T , by converting ϕ to a tree automaton.But there is a price to pay: in terms of the size of ϕ, the complexity becomes non-elementary.This type of trade-off is one of the central issues in dealing with logics over trees.Similar issues arise with evaluating formulae ϕ(x) in trees, that is, finding tuples s of nodes such that T |= ϕ(s).Ordered vs. unordered trees: In the standard definition of unranked trees in the XML context, children of the same node are ordered by a sibling ordering.If such an order is present, we speak of ordered unranked trees.In many cases, however, this ordering is irrelevant, and some unranked tree models, such as feature trees, do not impose any ordering on siblings.There is considerable difference between the expressiveness of logics and automata models depending on the availability of sibling ordering.The presence of ordering also affects the yardstick logic, since without order often counting is needed to match the power of automata models [Cou90].
The paper is organized as follows.After we give basic definitions in Section 2, we move to logics for ordered trees.In Section 3 we deal with MSO-related logics, including syntactic restrictions of MSO, a datalog-based logic, and the µ-calculus.In Section 4 we turn to FO-related logics, present analogs of LTL and CTL ⋆ that have been studied for expressing navigational properties, and also look at conjunctive queries over trees.In Section 5 we turn to trees that lack the sibling ordering, and show that in many logics some form of counting needs to be added to compensate for the missing ordering.We also review ambient and feature logics over edge-labeled trees.In Section 6 we look at the model-theoretic approach.
We consider an infinite first-order structure whose universe is the set of all unranked trees and obtain some well-known classes of trees by studying first-order definability (in the classic model-theoretic sense) over that structure.

Trees, logics, and automata
2.1.Tree domains, trees, and operations on trees.Nodes in unranked trees are elements of N * -that is, finite strings whose letters are natural numbers.A string s = n 0 n 1 . . .defines a path from the root to a give node: one goes to the n 0 th child of the root, then to the n 1 th child of that element, etc.We shall write s 1 • s 2 for the concatenation of strings s 1 and s 2 , and ε for the empty string.
We now define some basic binary relations on N * .The child relation is The next-sibling relation is given by: That is, s and s ′ are both children of the same s 0 ∈ N * , and s ′ is next after s in the natural ordering of siblings.We also use the first child relation: s ≺ fc s • 0. These are shown in Figure 2.
We shall use * to denote the reflexive-transitive closure of a relation.Thus, ≺ * ch is the descendant relation (including self): s ≺ * ch s ′ iff s is a prefix of s ′ or s = s ′ .The transitive closure of the next-sibling relation, ≺ * ns is a linear ordering on siblings: s • i ≺ * ns s • j iff i ≤ j.We shall be referring to younger/older siblings with respect to this ordering (the one of the form s • 0 is the oldest).
Let Σ be a finite alphabet.We define trees as structures that consist of a universe and a number of predicates on the universe.Definition 2.2 (Σ-trees).An ordered unranked tree T is a structure a∈Σ , where D is a tree domain, ≺ * ch and ≺ * ns are the descendant relation and the sibling ordering, and the P a 's are interpreted as disjoint sets whose union is the entire domain D.
An unordered unranked tree is defined as a structure D, ≺ * ch , (P a ) a∈Σ , where D, ≺ * ch , and P a 's are as above.
Thus, a tree consists of a tree domain together with a labeling on its nodes, which is captured by the P a predicates: if s ∈ P a , then the label of s is a.In this case we write λ T (s) = a.
Notice that when dealing with unranked trees we assume that each node has one label.Later we shall see a connection with temporal logics, where such a restriction on labeling is normally not imposed.However, one could always assume unique labeling in that case too, simply by collecting the set of all labels of a node (in this case the labeling alphabet becomes 2 Σ ).
2.2.First-order and monadic second-order logic.We shall only consider relational vocabularies, that is, finite lists (R 1 , . . ., R m ) of relation symbols, each R i with an associated arity n i .Over trees, relation symbols will be either binary (e.g., ≺ ch , ≺ ns , ≺ * ch ) or unary (the P a 's for a ∈ Σ).
Formulae of first-order logic (FO) are built from atomic formulae x = x ′ , and R(x), where x, x ′ are variables, and x is a tuple of variables whose length equals the arity of R, using the Boolean connectives ∨, ∧, ¬ and quantifiers ∃ and ∀.If a formula ϕ has free variables x, we shall write ϕ(x).Formulae are evaluated on a structure, which consists of a universe and interpretations for relations.Quantifiers ∃ and ∀ range over the universe of the structure.For example, an FO formula ϕ(x) = P a (x) ∧ ∃y∃z x ≺ * ch y ∧ y ≺ * ns z ∧ P b (y) ∧ P c (z) is true for nodes s in a tree T that are labeled a, have a descendant labeled b, which in turn has a younger sibling labeled c.
Formulae of monadic second-order logic (MSO) in addition allow quantification over sets.We shall normally denote sets of nodes by upper case letters.Thus, MSO formulae have the usual first-order quantifiers ∃xϕ and ∀xϕ as well as second-order quantifiers ∃Xϕ and ∀Xϕ, and new atomic formulae X(x), where X is a second-order variable and x is a first-order variable.An MSO formula may have both free first-order and second-order variables.If it only has free first-order variables, then it defines a relation on the universe of the structure.As an example, an MSO formula ϕ odd (x, y) given by the conjunction of x ≺ * ch y and says that y is a descendant of x and the path between them is of odd length.It says that there exist two sets, X and Y , that partition the path from x to y, such that x ∈ X, y ∈ Y , and the successor of each element in X is in Y , and the successor of each element in Y is in X.In the formula above, x ≺ * ch z ≺ * ch y is of course an abbreviation for (x ≺ * ch z)∧(z ≺ * ch y) and likewise for x ≺ * ch z ≺ ch v ≺ * ch y.Note that the relations ≺ ch and ≺ ns are definable, even in FO, from ≺ * ch and ≺ * ns : for example, In MSO one can define ≺ * ch from ≺ ch by stating the existence of a path between two nodes (and likewise ≺ * ns from ≺ ns ).However, it is wellknown that in FO one cannot define ≺ * ch from ≺ ch (cf.[Lib04]) and this is why we chose ≺ * ch and ≺ * ns , rather than ≺ ch and ≺ ns , as our basic relations.However, in all the results about MSO, we may assume that the basic relations are ≺ ch and ≺ ns .
In the introduction, we mentioned that we are mostly interested (in this survey) in Boolean and unary queries.A Boolean query over trees is just a set of trees closed under isomorphism (that is, a query cannot distinguish between two isomorphic trees).A unary query Q is a mapping that associates with each tree T a subset Q(T ) of its domain.Again, a query is required to be closed under isomorphism.
Definition 2.3 (Definability in logic).Given a logic L, we say that a Boolean query (that is, a set T of trees) is definable in L if there is a sentence ϕ of L such that T ∈ T iff T |= ϕ.We say that a unary query Q is definable in L if there is a formula ψ(x) of L such that s ∈ Q(T ) iff T |= ψ(s), for every tree T and a node s in T .
Figure 3: Run of an unranked tree automaton 2.3.Unranked tree automata.A nondeterministic unranked tree automaton, NUTA [Tha67, BMW01], over Σ-labeled trees is a triple A = (Q, F, δ) where Q is a finite set of states, F ⊆ Q is the set of final states, and δ is a mapping is a regular language over Q (normally represented by a regular expression over Q).A run of A on a tree T with domain D is a function if s is a node with n children, and it is labeled a, then the string This is illustrated in Figure 3.In particular, if s is a leaf labeled a, then ρ A (s) = q implies that ε ∈ δ(q, a).A run is accepting if ρ A (ε) ∈ F , that is, the root is in an accepting state.A tree T is accepted by A if there exists an accepting run.We let L(A) denote the set of all trees accepted by A. Such sets of trees will be called regular.
There could be different representations of NUTAs, depending on how regular expressions over Q are represented.These issues are discussed in [Nev02,MN05].
2.4.Binary trees and translations.A binary tree domain is a prefix-closed subset is, a node is either a leaf, or both its children are in D).It is common to define (binary) tree automata with both initial and final states, using the initial states to avoid conditions ε ∈ δ(q, a) imposed in the runs of NUTAs.That is, a (binary) nondeterministic tree automaton, NTA, is a quadruple where Q and F are as before, q 0 is the initial state, and δ is a function In this case a run ρ A b on a binary tree T with domain D is a function from D to Q such that if s is a leaf labeled a, then ρ A b (s) ∈ δ(q 0 , q 0 , a), and if s • 0, s • 1 belong to D, and s is labeled As before, a run is accepting if ρ A b (ε) ∈ F , and L(A b ) is the set of all binary trees for which there exists an accepting run of A b .Sets of trees of this form are regular sets (of binary trees).
There is a well-known regularity-preserving translation between unranked and ranked trees.It was first used in [Rab69] to show decidability of SωS (but here we shall apply it only to finite tree domains).The idea of the translation is that the first successor in the binary tree corresponds to the first child, and the second successor to the next sibling.More precisely, we define a mapping R : If D is an unranked tree domain, we let R(D) be {R(s) | s ∈ D} together with R(s) • 1 if s is a non-leaf last child, and R(s) • 0 if s a leaf, other than the last sibling (these additions ensure that R(D) is a binary tree domain).We define R(T ) to be a tree with domain R(D), where R(s) has the same label as s, and the added nodes are labeled by a symbol ⊥ ∈ Σ.An example is shown in Figure 4.
The following is a folklore result.Other regularity-preserving translations from unranked trees to binary trees exist.For example, [CNT04] views unranked trees as built from labeled nodes by means of a binary operation T @T ′ that attaches T ′ at the new youngest child of the root of T .This immediately yields a binary tree representation and an automaton construction, and of course an analog of Lemma 2.4 holds.

Ordered trees: MSO and its relatives
In the next two sections we only deal with ordered unranked trees.
As we mentioned already, MSO is often used as a yardstick logic for trees, because of its close connection to regular languages.The following result belonged to folklore, and was explicitly stated in [Nev99].
Theorem 3.1.A set of unranked trees is regular iff it is definable in MSO.
When restricted to strings and binary trees, this corresponds to well-known results by Büchi [Büc60] saying that MSO equals regular languages over strings, and by Thatcher, Wright [TW68], and Doner [Don70], saying that MSO equals regular (binary) tree languages.
There is also a close connection between automata, MSO, and the common formalism for describing schemas for XML documents called DTDs, which are essentially extended context-free grammars.A DTD d over an alphabet Σ is a collection of rules a → e a , where a ∈ Σ and e a is a regular expression over Σ.We shall assume there is at most one such rule for each a ∈ Σ.A Σ-labeled tree T satisfies d, if for each node s of T with n children, and ) is in the language denoted by e a .We write Sat(d) for the set of trees that satisfy d.
Each DTD is easily definable by an unranked tree automaton: in fact its states just correspond to labels of nodes.This, however, is too restrictive to capture full definability in MSO.In fact, DTDs (that is, sets of the form Sat(d)) are closed under neither unions nor complement, which makes DTDs unsuitable for capturing a logic with disjunction and negation.
However, a slight extension of DTDs does capture MSO.An extended DTD over Σ is a triple (Σ ′ , d ′ , g) where Σ ′ ⊇ Σ, with g being a mapping g : Σ ′ → Σ, and d ′ is a DTD over Σ ′ .We say that a Σ-labeled tree T satisfies (Σ ′ , d ′ , g) if there is a Σ ′ -labeled tree T ′ that satisfies d ′ such that T = g(T ′ ) (more formally, T is obtained by replacing each label a in T ′ by g(a)).We write Sat(Σ ′ , d ′ , g) for the set of trees that satisfy (Σ ′ , d ′ , g).
The following was established in [Tha67] and then restated using the DTD terminology in [PV00,Via01].
Theorem 3.1 talks about MSO sentences, but it can be extended to unary MSO queries using the concept of query automata [NS02].A (nondeterministic) query automaton over unranked Σ-labeled trees is a quadruple QA = (Q, F, δ, S) where A = (Q, F, δ) is an UNTA, and S is a subset of Q × Σ.Such a query automaton defines two unary queries Q ∃ QA and Q ∀ QA on unranked trees: Existential semantics query: [NS02,Nev99,FGK03]) For a unary query Q on unranked trees, the following are equivalent: QA for some query automaton QA.
Query automata, just as usual tree automata, have a deterministic counterpart; however, in the deterministic version, two passes over the tree are required.See [NS02] for details.
Theorems 3.1 and 3.3 are constructive.In particular, every MSO sentence ϕ can be effectively transformed into an automaton A ϕ that accepts a tree T iff T |= ϕ.Since tree automata can be determinized, this gives us a O( T ) algorithm to check whether T |= ϕ, if ϕ is fixed.1However, it is well-known that the size of A ϕ (even for string automata) cannot be bounded by an elementary function in ϕ [SM02].An even stronger result of [FG02] says that there could be no algorithm for checking whether T |= ϕ that runs in time O(f ( ϕ ) • T ), where f is an elementary function, unless Ptime=NP.
Nonetheless, these results do not rule out the existence of a logic L that has the same power as MSO and yet permits faster model-checking algorithms.Even looking at a simpler case of FO on strings, where results of [FG02] also rule out O(f ( ϕ )•|s|) algorithms for checking if a string s satisfies ϕ, with f being an elementary function, the logic LTL (linear-time temporal logic) has the same expressiveness as FO [Kam68] and admits a model-checking algorithm with running time 2 O( ϕ ) • |s|.
3.1.Logic ETL.The first logic for unranked trees that has the power of MSO and modelchecking complexity matching that of LTL appeared in [NS00] and was called ETL (efficient tree logic).It was obtained by putting syntactic restrictions on MSO formulae, and at the same time adding new constructors for formulae, which are not present in MSO, but are MSO-definable.
The atomic formulae of ETL are the same as for MSO, except that we are allowed to use both ≺ ch and ≺ * ch and are not allowed to use the next-sibling relation ≺ * ns .The formulae of ETL are then closed under Boolean combinations, guarded quantification, and path formulae.The rules for guarded quantification are as follows: ch X means that X only contains descendants of x.In this case ϕ cannot contain vertical path formulae (defined below).
Path formulae are defined below, and illustrated in Figure 5.
• if e is a regular expression over ETL formulae of the form ψ(u, v), then e ↓ (x, y) is a (vertical path) ETL formula.The semantics is as follows: T |= e ↓ (s, s ′ ) if there is a child-relation path s = s 0 , s 1 , . . ., s n = s ′ in T and a sequence of ETL formulae ) for all i, and the sequence ψ 0 . . .ψ k matches e.
We also define a slight syntactic modification ETL • of ETL, in which the closure under Boolean connectives is replaced by a rule that formulae are closed under taking Boolean combinations which are in DNF: that is, if Clearly the expressiveness of ETL • is exactly the same as the expressiveness of ETL.
Theorem 3.4.(see [NS00]) With respect to Boolean and unary queries, ETL and MSO are equally expressive.Furthermore, each ETL • formula ϕ can be evaluated on a tree T in time or there is a rule H i (x):-R 1 (x, ȳ), . . ., R s (x, ȳ) and a tuple b such that for each extensional predicate R i , the fact R i (ā, b) is true in D, and for each intensional predicate R i , the fact A monadic datalog query is a pair (P, H) where P is a monadic datalog program, and H is an intensional predicate.The value of H in P(D) is the output of this program on D.
We consider three unary predicates on unranked tree domains: Leaf, LastChild, and Root.Given a tree domain D, they are interpreted as Theorem 3.5.(see [GK04]) A unary query over unranked trees is definable in MSO iff it is definable in monadic datalog over extensional predicates ≺ fc , ≺ ns , Leaf, LastChild, Root, and P a , a ∈ Σ.
Furthermore, each monadic datalog query (P, H) can be evaluated on a tree T in time There are two proofs of this result in [GK04]: one codes query automata in monadic datalog, and the other one uses the standard reduction to ranked trees and the composition method (cf.[HT87]) for MSO games.
3.3.µ-calculus.Yet another way of getting a logic equivalent to MSO is suggested by a close connection between MSO and the modal µ-calculus L µ on ranked trees, which can easily be extended to the unranked case by using the connection between ranked and unranked trees.It was shown in [EJ91,Niw88] that every property of infinite binary trees definable in MSO is also definable in L µ .To deal with unranked trees, we shall define L µ over Σ-labeled structures that have several binary relations E 1 , . . ., E m , cf. [AN01].Formulae of L µ are given by where in µX ϕ(X), the variable X must occur positively in ϕ.Given a structure T with domain D, s ∈ D, and a valuation v for free variables (such that each v(X) is a subset of D), we define the semantics by Using the translation into ranked trees (or direct coding of automata), it is easy to show the following (see [BL05]): Proposition 3.6.The class of Boolean MSO queries on unranked trees is precisely the class of Boolean queries defined by If we consider unranked trees as structures with relations ≺ fc and ≺ ns , then they are acyclic, and hence the complexity of model checking is O( ϕ 2 • T ) [Mat02].Furthermore, results of [Mat02] tell us that one can strengthen Proposition 3.6: MSO equals alternation-free L µ over ≺ fc , ≺ ns .For alternation-free L µ formulae over unranked trees the complexity of model-checking further reduces to O( ϕ • T ), matching the complexity of monadic datalog.
It is also possible to characterize unary MSO queries over unranked trees in terms of the full µ-calculus L full µ (cf.[Var98]) which adds backward modalities 3(E − i )ϕ with the semantics [BL05]) The class of unary MSO queries on unranked trees is precisely the class of queries defined by There are other fixed-point constructions that have been shown to capture the power of automata and MSO over unranked trees; see, e.g.[NS98].

Ordered trees: FO and its relatives
We continue dealing with ordered trees, but now we move to logics closely related to firstorder, as opposed to monadic second-order.
While a lot is known about FO on both finite and infinite strings, it has not been nearly as extensively studied for trees until very recently.Recall that over strings -which we can view as trees with only unary branching -FO defines precisely the star-free languages (cf.[Tho97]), and over both finite and infinite strings FO has exactly the power of LTL [Kam68].It can further be characterized by aperiodicity of the syntactic monoid (cf.[Str94]).
In contrast, the natural analog of star-free expressions over binary trees captures not FO but MSO [PT93].Algebraic characterizations of FO-definable classes of binary trees have been obtained very recently [BS05, BW04, EW03], with [BS05] showing that FO-definability (without the descendant relation) is decidable for regular tree languages.One well-known equivalent logical description of FO on binary trees is Hafer-Thomas's theorem [HT87] stating that over finite binary trees, FO = CTL ⋆ (CTL ⋆ is a branching time temporal logic widely used in verification, cf.[CGP99], and it will be defined shortly).Actually, the result of [HT87] shows that CTL ⋆ is equivalent to MSO with second-order quantification over paths only, but over finite trees this fragment of MSO is equivalent to FO.
The interest in logics over unranked trees whose power is equal to or subsumed by that of FO stems from the fact that navigational features of XPath can be described in FO.XPath [CD99] is a W3C standard for describing paths in XML documents.For example, an XPath expression //a[//b]/c produces the c-labeled children of a-labeled nodes having a b-labeled descendant.Here // denotes descendant, / denotes child, and [ ] is a node test.The expression above looks for a-nodes (descendants of the root) in which the test [//b] is true (the existence of a node labeled b) and from there it proceeds to children of such nodes labeled c.While this is the syntax one typically finds in the literature on XPath, here we shall use a different syntax, highlighting connections with temporal logics.
In this section we shall look for connections between XPath, FO on trees, and temporal logics, which are designed to talk about properties of paths.
Logics introduced in the context of studying XPath, and more generally, navigational properties of XML documents, can be roughly subdivided into two groups.Firstly, one may try to establish analogs of Kamp's theorem (stating that FO = LTL over strings) for trees.Secondly, one can try to extend Hafer-Thomas's theorem (the equivalence FO = CTL ⋆ ) from binary to unranked trees.
Both ways are possible, and in both cases we get FO completeness results, stating that some temporal logics have precisely the power of unary FO queries.4.1.XPath and temporal logics.We start with LTL-like logics.First, recall the syntax of LTL over alphabet Σ: Formulae of LTL are interpreted over finite or infinite strings over Σ: a formula is evaluated in a position in a string.Given a string s = a 0 a 1 . .., we define the semantics as follows: for all i ≤ k < j; • the semantics of the dual ϕSϕ (ϕ "since" ϕ ′ ) is that there exists j ≤ i such that (s, j) |= ϕ ′ and (s, k) |= ϕ for all j < k ≤ i.
Note that it is possible to avoid X and X − by defining a strict semantics for U and S, without requiring ϕ to be true in (s, i).
We now consider a logic TL tree (tree temporal logic, cf.[Mar05,Sch92]) defined as follows: , where * is either 'ch' (child) or 'ns' (next sibling).We define the semantics with respect to a tree T and a node s in T : , and for all The semantics of S ch is defined by reversing the order in the semantics of U ch , and the semantics of X ns , X − ns , U ns , and S ns is the same by replacing the child relation with the next sibling relation.
TL tree naturally defines unary queries on trees, and it also defines Boolean queries: we say that T |= ϕ if (T, ε) |= ϕ.
Theorem 4.1.(see [Mar05]) A unary or Boolean query over unranked trees is definable in In CTL ⋆ -like logics, there are two kinds of formulae: those evaluated in nodes of trees, and those evaluated on paths in trees.This is similar to the situation with XPath, which has filter expressions evaluated on nodes, and location path expressions, which are evaluated on paths in XML trees.We shall now present two logics: CTL ⋆ with the past, in the spirit of [KP95], and a CTL-like reformulation of XPath, as presented in [Mar05].
We start with XPath-inspired logics, and present them using a slight modification of the syntax that keeps all the main XPath constructions and yet makes the connection with temporal logics more visible.
The language CXPath [Mar05] (Conditional XPath) is defined to have node formulae α and path formulae β given by: where step is one of the following: ≺ ch , ≺ − ch , ≺ ns , or ≺ − ns .Intuitively Eβ states the existence of a path starting in a given node and satisfying β, ?α tests if α is true in the initial node of a path, and / is the composition of paths.
The language Core XPath [GK+05, GKP05] is obtained by only allowing step + as opposed to (step/?α) + in the definition of path formulae.Notice that since step + = (step/?true)+ , where true = a∈Σ a, we have Core XPath ⊆ CXPath.
The earlier example of an XPath expression (//a[//b]/c) can be represented in this syntax by a node formula c ∧ E(≺ − ch /?a/ ≺ + ch /?b) saying that a node is labeled c, and there is a path that starts by going to its parent, finding a there, and then going to a descendant of that a and finding a b.
Core XPath corresponds to XPath as defined by the W3C [CD99], while CXPath represents an addition to XPath proposed by [Mar05].This addition is essentially the "until" operator of temporal logic: for example, to represent the strict version of until (that is, to say that in the next element of a path aUb holds), one could write ≺ ch /?b ∨ (≺ ch /?a) + / ≺ ch /?b.
Node formulae of either CXPath or Core XPath naturally define unary queries on trees.These can be characterized as follows.
Theorem 4.2.a) (see [Mar05]) The node formulae of CXPath have precisely the power of FO unary queries.b) (see [MdR04]) The node formulae of Core XPath have precisely the power of unary FO 2 queries (that is, FO with two variables) in the vocabulary ≺ ch , ≺ * ch , ≺ ns , ≺ * ns .
Part a) of Theorem 4.2 can also be extended to formulae in two free variables, see [Mar05].

4.2.
A CTL ⋆ -like logic.The logics CTL (computation tree logic) and CTL ⋆ are branching time temporal logics used in verification of reactive systems.They are normally defined without past connectives, but here we use the syntax close to that of [KP95] to make it possible to reason about the past.In these logics, one also has node (usually called state) formulae and path formulae, but path formulae are evaluated on paths, not on arbitrary pairs of nodes.
We define CTL ⋆ past node formulae α, and child and sibling path formulae β ch and β ns , as follows: Given a tree, a child-path π ch is a sequence of nodes on a path from the root to a leaf, and a sibling-path is a sequence π ns of nodes of the form s • 0, . . ., s • (n − 1) for a node s with n children.We define the semantics of node formulae with respect to a node in a tree, and of path formulae with respect to a path and a node on the path (i.e., we define the notion of (T, π * , s) |= β * , for * being 'ch' or 'ns').The definitions for S ch and for sibling-paths are analogous.

L. LIBKIN
The following can be seen as an analog of the equivalence FO = CTL ⋆ for finite binary trees [HT87].While the proof the connection between ranked and unranked tree, the straightforward translation from the binary tree fails because paths over translations of unranked trees may change direction between child and sibling-paths arbitrarily many times.
Theorem 4.3.(see [BL05]) A unary or Boolean query over unranked trees is definable in 4.3.Extensions of FO and regular languages.Over strings, FO falls short of all regular languages, as it defines precisely the star-free ones.However, using arbitrary regular expressions is often convenient in the context of navigating in XML documents.
Given a class C of regular expressions, define FO(C) * as an extension of FO with the rules: (i) if e is a regular expression in C over FO(C) * formulae ψ(u, v), then e ↓ (x, y) is a formula, and (ii) if e is a regular in C over FO(C) * formulae ψ(u), then e → (x) is a formula.The semantics is the same as for the case of ETL.If formulae ψ are restricted to be Boolean combinations of atomic formulae P a , a ∈ Σ, we obtain the logic FO(C).
Let StarFree be the class of star-free expressions, and Reg the class of all regular expressions.For more on FO(Reg) and FO(Reg) * and their connections with fragments of MSO such as the path logic [Tho87], see [BLN06,NS00].
4.4.Conjunctive queries over unranked trees.Conjunctive queries are a very important class of database queries: they correspond to the ∃, ∧-fragment of FO.These are the same queries that can be expressed by selection, projection, and join in relational algebra, and thus they form the core of database queries.Their complexity had been studied extensively.In general, the complexity of evaluating a conjunctive query ϕ over a database D is in NP, in terms of both the size of ϕ and the size of D. In fact, the problem is NP-hard, and there has been a large body of work on classifying tractable cases (see, e.g., [GLS01,GSS01]).
In the case of unranked trees, conjunctive queries are formulae of the form where each R i is either P a (z) or z ≺ z ′ , where z, z ′ are variables among x, ȳ, and ≺ is one of ≺ ch , ≺ * ch , ≺ ns , or ≺ * ns .We write CQ(≺ 1 , . . ., ≺ m ) to denote the class of conjunctive queries over unranked trees in which only unary predicates P a and binary predicates among ≺ i can be used.
If we restrict ourselves to classes of conjunctive queries that use at most two binary predicates, then there is a complete classification for the complexity of query evaluation on unranked trees.Theorem 4.5.(see [GKS04]) The maximal tractable classes of queries CQ(≺ 1 , . . ., ≺ m ), where all ≺ i 's are among {≺ ch , ≺ * ch , ≺ ns , ≺ * ns }, are CQ(≺ ch , ≺ ns , ≺ * ns ) and CQ(≺ * ch ); all others are NP-hard.
In fact, [GKS04] provided a more general (but rather technical) criterion for checking when evaluation is in Ptime, and that condition can be used for other relations present in a query.
Conjunctive queries can also be used to capture all FO over unranked tree, even if more than one free variable is used, assuming path formulae of CXPath can be used as atomic predicates.More precisely, every FO formula ϕ(x) over unranked trees is equivalent to a union of conjunctive queries whose atomic predicates are β(x, x ′ ), where β ranges over path formulae of CXPath [Mar05].

Unordered trees
In unordered trees, nodes can still have arbitrarily many children, but the sibling ordering ≺ ns is no longer available.That is, we view trees as structures A simple explanation for this comes from a modified notion of unranked tree automata and query automata for unordered unranked trees.A counting nondeterministic unranked tree automaton is a tuple A c = (Q, F, δ), where, as before, Q is a set of states, and F ⊆ Q is a set of final states.Let V Q be the set of variables {v k q | q ∈ Q, k > 0}.Then the transition function δ maps each pair (q, a), for q ∈ Q and a ∈ Σ, into a Boolean function over V Q .A run of A on an unordered tree T with domain D is then a mapping ρ Ac : D → Q such that if ρ Ac (s) = q for a node s labeled a, then the value of δ(q, a) is 1, where each variable v k q i is set to 1 if s has at least k children s ′ with ρ Ac (s ′ ) = q i , and to 0 otherwise.A run is accepting if ρ Ac (ε) ∈ F , and the set of unordered trees accepted by A c (that is, trees for which there is an accepting run) is denoted by L u (A c ).
A counting query automaton QA c is defined as (Q, F, δ, S) where S ⊆ Q × Σ; it selects nodes s in a run ρ where (ρ Ac (s), λ T (s)) ∈ S. As before, it can be given both existential and universal semantics.
The following appears not to have been stated explicitly, although it follows easily from results in [Nev99, NS02, SSM03].
Theorem 5.1.a) A set of unordered unranked trees is MSO-definable iff it is of the form L u (A c ) for a counting nondeterministic unranked tree automaton A c .b) A unary query over unordered unranked trees is MSO-definable iff it is definable by a counting query automaton QA c under either existential or universal semantics.5.1.MSO and FO over unordered trees.Now we look at several alternative characterizations of MSO and FO over unordered unranked trees that exploit the counting connection.
Define the counting µ-calculus C µ (cf.[JL01]) as an extension of L µ with formulae 3 ≥k (E)ϕ.The semantics of (T, s) |= 3 ≥k (E)ϕ is as follows: there exist distinct elements s 1 , . . ., s k such that (s, s i ) ∈ E and (T, s i ) |= ϕ for every 1 ≤ i ≤ k.The next result follows from [Wal02], as was noticed in [JL01]: Theorem 5.2.Over unordered unranked trees, MSO and C µ [≺ ch ] have precisely the same power with respect to Boolean queries.
In fact, it is not hard to show that MSO can be translated into alternation-free C µ , and thus evaluated with complexity O( T • ϕ ), where ϕ is an alternation-free C µ formula.
For first-order logic, counting extensions of both the temporal logic TL tree and CTL ⋆ give us analogs of Kamp's and Hafer-Thomas's theorems.We define TL tree count as a version of TL tree in which only modalities for the child relation are used, but in addition we have formulae X k ch ϕ, with the semantics that (T, s) |= X k ch ϕ iff there are at least k children s ′ of s such that (T, s ′ ) |= ϕ.
We also extend CTL ⋆ with counting.In this counting extension CTL ⋆ count , we have new state formulae EX k ch α, where α is a state formula, with the same semantics as above.Theorem 5.3.(see [MR03,Sch92]) Over unordered unranked trees, the classes of Boolean queries expressed in FO, TL tree count , and CTL ⋆ count over binary relation ≺ ch , are the same.
For unary queries, the equivalence FO = TL tree count still holds [Sch92], and FO can be shown to be equivalent to an extension of CTL ⋆ with both counting and the past [BL05,Rab02].
Adding counting does not increase the complexity of model-checking in temporal logics, which is 2 O( ϕ ) • T , cf. [CGP99].
Unordered fragments of XPath have also been looked at in the literature.For example, [BFK03] showed that the restriction of positive (no negation) Core XPath that only uses ≺ ch and ≺ * ch is equivalent to existential positive FO formulae over the vocabulary that includes both ≺ ch and ≺ * ch .
5.2.Extensions and more powerful counting.Consider now a scenario in which we deal with unordered trees, but in our formulae we can refer to some arbitrary ordering on siblings: after all, in any encoding of a tree, siblings will come in some order.Of course we do not want any particular order to affect the truth value, so we want our formulae, even if they use an ordering, to be independent of a particular ordering that was used.This is the standard setting of order-invariance, a very important concept in finite model theory, cf.[Lib04].We say that an MSO sentence ϕ over vocabulary including ≺ * ch and ≺ * ns is ≺ ns -invariant if for any unordered tree T and any two expansions T ≺ 1 ns and T ≺ 2 ns with sibling-orderings ≺ 1 ns and ≺ 2 ns we have T ≺ 1 ns |= ϕ ⇔ T ≺ 2 ns |= ϕ.Any ≺ ns -invariant sentence defines a Boolean query on unordered trees.
We now define MSO mod [Cou90] as an extension of MSO with modulo quantifiers: for each set variable X, and k > 1, we have set new formulae Q k (X) which are true iff the cardinality of X is congruent to 0 modulo k.
Further extensions in terms of arithmetic power have been considered in [SSM03,SS+04].Recall that Presburger arithmetic refers to the FO theory of the structure N, + , and it is known that this structure admits quantifier elimination in the vocabulary (+, <, 0, 1, (∼ k ) k∈N ) where n ∼ k m iff n − m = 0(mod k).We next define Presburger MSO, called PMSO, as an extension of MSO over unordered trees with the following rule: if ϕ(x, y, X) is a PMSO formula and α(v) a Presburger arithmetic formula with | X| = |v| = n, then [ϕ/α](x, y, X) is a PMSO formula.Given valuation s, s 0 , S for free variables, with S = (S 1 , . . ., S n ), let m i be the number of children of s 0 that belong to S i , that is, the cardinality of the set It is easy to see that MSO MSO mod PMSO over unordered trees.Still, PMSO is captured by a decidable automaton model.Define Presburger unordered tree automata just as counting automata except that δ maps pairs from Q×Σ into Presburger formulae over v q , for q ∈ Q.We interpret v q as the number of children in state q, and a transition is enabled if the corresponding Presburger formula is true in this interpretation.That is, in a run ρ of such an automaton, if ρ(s) = q, the label of s is a and δ(q, a) = χ(v q 1 , . . ., v qm ), then χ(n 1 , . . ., n m ) is true, where n i is the number of children s ′ of s such that ρ(s ′ ) = q i .Theorem 5.5.(see [SSM03]) Presburger unordered tree automata and PMSO are equivalent.Furthermore, both emptiness and universality are decidable for Presburger unordered tree automata.
Further extensions with counting have been considered for fixed-point logics [SS+04] and the µ-calculus with modulo-quantifiers [BL05].5.3.Edge-labeled unordered trees.While in the early days of tree-based data models there was some debate as to whether labels should be on edges or nodes, the arrival of XML seems to have settled that dispute.Nonetheless, there are several areas where edge-labeled trees play a prominent and role, and traditionally logical formalisms have been designed for such data.First, there are logics for feature trees, which are a special case of feature structures used extensively in computational linguistics [Car92].Second, in recent work on spatial logics, used for describing networks and mobile agents [CG00], one looks at modal logics over unordered edge-labeled trees.
In the setting of feature trees, one has an infinite set of features F, and in an unordered unranked tree every edge is labeled by an element f ∈ F such that each node s has at most one outgoing edge labeled f for each f ∈ F. Furthermore, nodes may be labeled by elements of some alphabet Σ, as before.It is thus natural to model feature trees as structures D, (E f ) f ∈F , (P a ) a∈Σ such that the union of all E f 's forms the child relation of a tree, and no node has two outgoing E f -edges.

L. LIBKIN
In the context of computational linguistics, one commonly used logic for feature trees [Bla94] is the propositional modal logic that, in the context of feature structures (not necessarily trees), is also often supplemented with path-equivalence, stating that from a certain node, one can reach another node following two different paths.This is the setting of the Kasper-Rounds logic [RK86].Over trees, however, path-equivalence is the same as equality of paths.A more powerful logic proposed in [Kel93] combined the Kasper-Rounds logic with the propositional dynamic logic.Its formulae are defined by where e, e ′ are regular expressions over F. Formulae are evaluated in nodes of a feature tree T .We have (T, s 0 ) |= 3(e)ϕ if there is a path (s 0 , s 1 ) a word in the language denoted by e. Furthermore, (T, s) |= e ≈ e ′ if there is a node s ′ that can be reached from s by a word in e as well as a word in e ′ .This semantics is normally considered over graphs, but over trees this is equivalent to saying that there is a node reachable by an expression in the language denoted by e ∩ e ′ .That is, e ≈ e ′ is equivalent to 3(e ∩ e ′ )true, and thus the Kasper-Rounds logic is effectively a reachability logic over trees.
The reader is referred to [Kel93] for computational linguistics applications of this logic.In terms of expressiveness it is clearly contained in MSO, and if all expressions e, e ′ are star-free, then in FO as well, as long as we have the descendant relation.
Automata for feature trees, based on the algebraic approach to recognizability [Cou90], were considered in [NP93] (which also showed that over flat feature trees the automaton model coincides with a simple counting logic).5.4.An ambient logic for trees.Ambient logics are modal logics for trees that have been proposed in the context of mobile computation [CG00] and later adapted for treerepresented data [Car01,CG01].One views trees as edge-labeled and defines them by the grammar T, T ′ := Λ | T |T ′ | a[T ], a ∈ Σ, with the equivalences that | is commutative and associative, and that T |Λ ≡ T .Here Λ is the empty tree, | is the parallel composition, and a[T ] adds an a-labeled edge on top of T .If we extend ≡ to a congruence in the natural way, then every tree is equivalent to one of the form a 1 [T 1 ]| . . .|a m [T m ], which is viewed as a tree whose root has m outgoing edges labeled a 1 , . . ., a m , with subtrees rooted at its children being T 1 , . . ., T m .There were several similar logics proposed in [CCG03, Car01, CG01, CG00, DLM04].Here we consider the logic from [CCG03] whose formulae are given by The semantics is as follows: • ⊥ is false; • Λ is only true in a tree equivalent to Λ; Variations appear in the literature, e.g. with the Kleene star in [DLM04] and recursion in [CG01].
The study of ambient logics for trees took a very different path compared to other logics seen in this survey; in particular, the focus was on type systems for tree languages and thus on proof systems for logics, rather than model-checking, its complexity, automata models, and comparison with other logics.Several lines of work closely resemble those for node-labeled trees: e.g., [DLM04] introduced Presburger conditions on children, defined an automaton model, and proved decidability, similarly to [SSM03,SS+04].
However, the ambient logic does not take us outside of the MSO expressiveness: this can be seen by going from edge-labeled trees to node-labeled ones.The translation is simple: the label of each edge (x, y) becomes the label of y.The root will have a special label Root that cannot occur as a label of any other node.The only modification in the logic is that now we have formulae Λ a for a ∈ Σ, which are true in a singleton-tree labeled a.The resulting logic is easily translated into MSO.For example, ϕ|ϕ ′ states that the children of the root can be partitioned into two sets, X and X ′ , such that the subtree that contains all the X-children satisfies ϕ and the subtree that contains all the X ′ -children satisfies ϕ ′ .For ϕ ⊲ ϕ ′ , one can consider ¬(ϕ ⊲ ϕ ′ ) saying that there exists a tree T ′ such that T ′ |= ϕ and T |T ′ |= ¬ϕ ′ , and use nondeterministic counting automata to guess this tree T ′ .
Since moving labels from edges to nodes and back can be defined in MSO, we see that the ambient logic is embedded into MSO.However, to the best of the author's knowledge, this direction has never been seriously pursued, and the exact relationship between ambient logics and other logics described in this survey is still not well understood.

Automatic structures
In this section we look at a different kind of logics for unranked trees, using the standard approach of model theory.So far we represented each tree as a structure and looked at definability over that structure.Now we want to consider structures whose universe is the set of all trees.Definability over such structures allows us to describe sets of trees and, more generally, relations over trees.Choosing the right operations on trees, we shall find structures where definable sets are precisely the regular languages.Such structures are very convenient for proving that certain properties of trees are regular, as it is sometimes easier to define properties logically than to construct automata for them.
Let Tree(Σ) be the set of all Σ-labeled unranked trees.We consider structures of the form M = Tree(Σ), Ω where Ω is a set of relation, constant, and function symbols, interpreted over Tree(Σ).
Let Def n (M) be the family of n-dimensional definable sets over M: that is, sets of the form where ϕ(x 1 , . . ., x n ) is a first-order formula in the vocabulary Ω.We shall be looking at structures M so that definable sets would be relations definable in MSO or other logics.In L. LIBKIN particular, such relations will be given by automata, and thus structures M of this kind are called automatic structures.
6.1.Automatic structures on strings.Before we move to trees, we first survey automatic structures over strings, cf.[BG00,BL+03].In this case we consider structures of the form Σ * , Ω .Our first example has the following relations in Ω: Thus, Def 1 (S univ ) contains exactly the regular languages over Σ.Furthermore, the conversion of formulae over S univ to automata is effective [BG00] and the theory of S univ is decidable.In fact the theory of every structure that is interpretable in S univ is thus decidable.
As an example, consider the structure Q, < .Since it is isomorphic to {0, 1} * 1, < lex , where < lex is the lexicographic ordering (which is easily definable in S univ ), we obtain the well-known decidability of Q, < .
A restriction of S univ that does not have the equal length predicate, that is, S = Σ * , ≺ , (L a ) a∈Σ is known to be strictly weaker that S univ in every dimension: in particular, el is not in Def 2 (S), and Def 1 (S) is precisely the class of star-free languages [BL+03].
Notice that both the empty string ε and functions g a (s) = s •a are definable in S, and hence another well-known theory interpretable in S and S univ is that of unary term algebras.However, it is known that for binary term algebras, adding relations like ≺ results in undecidable theories [MNT98,Ven87].In particular, if we want to keep an analog of the ≺-relation (which is MSO-definable), we cannot introduce an operation like the | operation in the ambient logic, and still have a decidable theory.
6.2.Automatic structures on trees.To get structures over Tree(Σ) that define regular languages and relations 2 , we find natural analogs of ≺, L a , and el for trees.For two trees T 1 and T 2 with domains D 1 and D 2 , we say that T 2 is an extension of T 1 , written T 1 T 2 , if D 1 ⊆ D 2 , and the labeling function of T 2 agrees with the labeling function of T 1 on D 1 .It will actually be more convenient to work with two extension relations: Extension on the right → : : For T 1 → T 2 , we require that every s ∈ D 2 − D 1 be of the form s ′ • i when s ′ • j ∈ D 1 for some j < i.
Extension down ↓ : : For T 1 ↓ T 2 , we require that every s ∈ D 2 − D 1 have a prefix s ′ which is a leaf of T 1 .
Clearly T 1 T 2 iff there is T ′ such that T 1 → T ′ and T ′ ↓ T 2 , so in terms of definability we do not lose anything by using → and ↓ instead of .
We define L a to be true in a tree T if the rightmost node is labeled a.That is, the node s ∈ D which is the largest with respect to < lex is labeled a.For the analog of el, recall that in the standard representation of strings as first-order structures, the domain is an initial segment of N, corresponding to the length of the string.Hence, el(s 1 , s 2 ) means that if strings are represented as structures, their domains are the same.We thus introduce a predicate ≈ dom such that Now we define analogs of S univ and S: Notice the difference with the string case, where removing el (domain equality) resulting in a smaller class of one-dimensional definable sets: star-free languages.On the other hand, even over binary trees, the notions of star-free and regular coincide [PT93].
Working with T univ makes it easy to write rather complicated properties of tree languages, and then Theorem 6.1 implies that those languages are regular.For example, if X ⊆ Tree(Σ) is regular, then the set of trees T such that all their extensions can be extended on the right to a tree in X is regular.Indeed, this is defined as ϕ(T ) = ∀T ′ T T ′ → ∃T ′′ (T ′ → T ′′ ∧ α X (T ′′ )) , where α X defines X (by Theorem 6.1, we know such α X exists).Then Theorem 6.1 again tells us that ϕ defines a regular language.Furthermore, the conversions from formulae to automata are effective for both T and T univ , which implies decidability of their theories.
Other logics over unranked trees can be naturally represented over these structures.Consider, for example, a restriction of first-order logic over T or T univ in which all quantification is over branches.A branch is a tree T such that the set {T ′ | T ′ T } is linearly ordered by .Let Def η 1 be the class of sets of trees (equivalently, Boolean queries over trees) definable in this restriction.Proposition 6.2.(see [BLN06]) Def η 1 (T) is precisely the class of FO-definable Boolean queries over unranked trees, and Def η 1 (T univ ) is the class of Boolean queries definable in a restriction of MSO in which quantification is allowed only over sets linearly ordered by ≺ * ch or by ≺ * ns .
For more results of this type, see [BLN06].We present here a somewhat random sample of other directions that work on logics for unranked trees has taken or may take in the future.We concentrate on streaming applications, and then briefly describe other directions.
Streaming XML documents.A typical XML document is a sequence of matching opening and closing tags, with some data between then.For example, the sequence of opening and closing tags corresponding to a tree is shown in Figure 6.Thus, an XML tree naturally has a string representation.For example, for the tree in Figure 6, such a representation is abaāccb bb ab bccāā, where we use a label, say a, for the opening tag <a>, and ā for the closing tag </a>.More generally, for an ordered unranked tree T we define inductively its string representation str(T ): • if T is a single node labeled a, then str(T ) = aā • if T has a root labeled a, with n children s 0 ≺ ns . . .≺ ns s n−1 , such that T i is the subtree rooted at s i , i < n, then str(T ) = a str(T 0 ) . . .str(T n−1 ) ā.
If an XML document T is transmitted as a stream, then the object we work with is precisely str(T ).Furthermore, we may not have the whole string str(T ) available, or may need to compute some of its properties without looking at the whole string (for instance, a device receiving the stream may have memory limitations and cannot store the entire stream).One possible model for this scenario was proposed in [SV02]: in this model, one processes the stream str(T ) by using a finite string automaton.It is natural to ask then what kinds of properties of trees can be recognized by finite automata that run on their streamed representations.More precisely, one is interested in tree languages of the form L str A = {T | str(T ) is accepted by A}, where A is a string automaton.(1) This survey has concentrated primarily on Boolean and unary queries.While these are sufficient in many applications, there are formalisms that require more general nary queries.For example, the core expressions of XQuery can be seen as rearranging arbitrary n-tuples of nodes selected from a tree as another tree.The logical study of XQuery is just beginning [Koc05], and there are several papers that show how to extend results from logics that define Boolean and unary queries to arbitrary n-ary queries.For example, [Sch00] does it for queries definable in FO(Reg)-like logics.Using a similar approach, [ABL06] shows how to combine temporal logics over trees to define n-ary queries.An extension of unranked tree automata to n-ary queries is presented in [NP+05].
(2) While we have a number of logics that provide a declarative approach to expressing properties of trees and yet match (or are close to) the complexity of the procedural automata formalism, it is not really understood what causes certain logics to have such a nice behavior.There must be some intrinsic properties of logics that lead to good model-checking algorithms (in a way similar to, say, finite-or tree-model properties being an explanation for decidability).
(3) Closely related to the first item is the issue of succinctness of logics, measured as the size of formulae needed to express certain properties.Initial investigation on the issue of succinctness for logics on ranked trees was done in [GS03] and some logics have been shown to be much more succinct than others, but more needs to be done.In view of the standard translation between ranked and unranked trees, it is likely that results for binary trees will be sufficient.(4) The connection between FO, MSO, temporal logics and logics used in the programming languages and computational linguistics communities must be understood.
The focus was quite different, as we mentioned earlier: for example, many questions about the complexity and expressiveness of ambient logics are unresolved.Some very recent results in this direction are reported in [BTT05].(5) XML trees in addition to labels have data values associated with some nodes (typically attribute values or PCDATA values).Adding values from a potentially infinite set and just equality over them immediately leads to undecidable formalisms.This is observed, in particular, in the study of XML constraints.Some typically considered constraints include keys and foreign keys, that arise naturally when relational data is converted into XML.Keys say that a certain sequence of attributes identifies a node uniquely.A key is unary if it consists of one attribute (for example, a unique id would be a unary key, while a pair (firstname,lastname) can be a key consisting of two attributes).A foreign key states that a sequence of attributes of each node labeled by a 1 should also occur as a sequence of attributes of some other node labeled a 2 .XML specifications may consist of DTDs together with constraints.However, their interaction could be quite complicated.In fact, [FL02] showed that it is undecidable whether a specification that consists of a DTD and a set of keys and foreign keys is consistent.However, if all keys and foreign keys are unary, then consistency checking is NP-complete.
It would be nice to find a purely logical explanation for this type of results.Decidability restrictions studied in [NSV01,BPT01] are very weak for this purpose.

L. LIBKIN
However, a recent line of results shows much more promise.Consider trees that can carry data values, and assume that we can test them for equality, that is, we have a binary relation ∼ that is true if two nodes in a tree have the same data values.Then FO 2 over such trees with the ∼ relation and the successor relation is decidable [B+06a].Here FO 2 refers to FO with two variables.Notice that for expressing unary constraints two variables suffice.It is open whether the descendant can be added while preserving decidability; the only resolved case is that of strings, where indeed FO 2 over the successor relation, the linear ordering, and the ∼ relation is decidable [B+06b].

Figure 1 :
Figure 1: A ranked (binary) and an unranked tree

Figure 2 :
Figure 2: Basic relations for unranked trees

Figure 4 :
Figure 4: A unranked tree T and its translation R(T )

Lemma 2. 4 .
For every NUTA A, there is an NTA A b such that L(A b ) = {R(T ) | T ∈ L(A)}, and conversely, for every NTA A b there is an NUTA A such that the above holds.Moreover, A b can be constructed from A very fast, in Dlogspace [GK+05].

Figure 5 :
Figure 5: The semantics of path formulae of ETL
a ) a∈Σ Theorem 6.1.(see[BLN06]) a) For every n ≥ 1, Def n (T univ ) is precisely the class of regular n-ary relations over Tree(Σ).b) Def 1 (T) = Def 1 (T univ ) is the class of regular unranked tree languages, but for every n > 1, Def n (T) Def n (T univ ).

Figure 6 :
Figure 6: An XML document as a tree and as a sequence of tags
The predicate H is called the head of the rule, and P 1 , . .., P k are called its body.Every variable that appears in the head is required to appear in the body.Given a datalog program P, predicates which appear as a head of some rule are called intensional, and other predicates are called extensional.If all intensional predicates are monadic (that is, of the form H(x)), then P is a monadic datalog program.Given a datalog program P with extensional predicates P 1 , . . ., P m and intensional predicates H 1 , . . ., H ℓ , and a structure D = D, P D 1 , . . ., P D m that interprets each p-ary predicate P i as P D i ⊆ D p , we define P(D) as the least fixed point of the immediate consequence operator.This operator takes a structure H [GK04,GK02]hecking algorithm.3.2.Monadic datalog.Another approach to obtaining the full power of MSO while keeping the complexity low is based on the database query language datalog (cf.[AHV95]); it was proposed in[GK04,GK02].A datalog program can be viewed as a prolog program without function symbols.Datalog is often used to extend expressiveness of database queries beyond FO.A datalog program consists of a sequence of rules H :-P 1 , . . ., P k , where H and all P i 's are atoms: that is, atomic formulae of the form E(x). ′ = D, H ′ 1 , . . ., H ′ ℓ and produces another structure H ′′ = D, H ′′ 1 , . . ., H ′′ ℓ such that a tuple ā is in We shall list explicitly binary relations E i , writing L µ [E 1 , . . ., E m ] to refer L µ formulae that only use those relations.An L µ formula ϕ without free variables naturally defines a unary query on trees ({s | (T, s) |= ϕ}) and a Boolean query on trees (by checking if (T, ε) |= ϕ).
s is in the least fixed point of the operator defined by ϕ; in other words, ifs ∈ {P | {s ′ | (T, v[P/X], s ′ ) |= ϕ} ⊆ P },where v[P/X] extends the valuation v by v(X) = P .
[FS93]nary relation; L a (s) is true iff the last symbol of s is a;• el is a binary relation; el(s, s ′ ) is true iff |s| = |s ′ |.Let S univ be the structure Σ * , ≺, (L a ) a∈Σ , el .Then S univ is the universal automatic structure: that is, relations Def n (S univ ) are precisely the regular relations.Following a standard definition -see, e.g.,[FS93]-we say that a relation S ⊆ (Σ * ) n is regular iff there is an automaton A over alphabet (Σ ∪ {#}) n that accepts precisely the strings [s], for s = (s 1 , . . ., s n ) ∈ S. The length of [s] is max i |s i |, and the jth symbol of [s] is a tuple (σ 1 , . . ., σ n ), where σ i is the jth symbol of s i if |s i | ≤ j, and # otherwise.