1.1 Related Work

The extension of the μ-calculus with nominals, inverse programs and graded modalities is known as the fully enriched μ-calculus ^[10]. Nominals are intuitively interpreted as singleton sets, inverse programs are used to express past properties (backward navigation along accesability relations), and graded modalities express numerical constraints on the number immediate successor nodes ^[10]. However, satisfiability/validity of the fully enriched μ-calculus was proven by Bonattiand Peron to be undecidable ^[11]. Nevertheless, Barcenas et al. ^[4] recently showed that the fully enriched μ-calculus is decidable in single exponential time when its interpretations are restricted to finite trees. Graded modalities in the context of trees are used to constrain the number of children nodes with respect to natural numbers. In this work, we introduce a generalization of graded modalities.

This generalization considers numerical bounds on children with respect to Presburger arithmetical expressions, as for instance ϕ>ψ, which restricts the number of children where ϕ holds to be strictly greater than the number of children where ψ is true. Other works have previously considered Presburger constraints on tree logics. MSO with Presburger constraints was shown to be undecidable by Seidl et al. ^[31]. Demri and Lugiez proved a PSPACE-complete bound on the propositional modal logic with Presburger constraints ^[16]. A tree logic with a fixed-point and Presburger constraints was shown to be decidable in EXPTIME by Seidl et al. ^[33,32]. In the current work, we push decidability further by allowing nominals and inverse programs in addition to Presburger constraints.

Regarding expressiveness, in ^[17] is proposed an extension of MSO with counting on unranked trees, together with the corresponding weighted automata. Other forms of counting considering more extensive tree regions, such as ancestors or descendants, have been studied in ^{[37,2,8,39,5,34,1,24]}, however in contrast with the current work, these works consider node occurrence constraints with respect to natural numbers only. An extension of first order logic with two variables FO² with counting quantifiers interpreted over two forests of ranked trees was recently proposed in ^[13,14]. The counting quantifiers consist of existential ∃#k#∈≤,≥,= restrictions with respect to a constant k. This logic was shown to be in NEXPTIME.

As in this article, Fischer-Ladner satisfiability algorithms for counting extensions of the μ-calculus for trees are introduced in ^[4,5].

In these works, it was also showed that these counting constraints with respect to numbers only, although exponentially more succinct, does not introduce extra-expressive power. This allowed to use the traditional Fixed-Point Theorem for the μ-calculus to prove the algorithm correctness. Contrastingly, in the current work we propose a counting extension of the μ-calculus with full Presburger arithmetic, which clearly implies more expressive power. In order to prove the algorithm correctness, we prove a generalization of the Fixed-Point Theorem for the Presburger extension of the μ-calculus for trees, which is also technical result of independent interest.

Complexity and succinctness of regular tree (string) languages extended with counting and interleaving operators have been extensively studied in ^{[28,27,19,4,15]}. In ^[19], Gelade shows that the interleaving operator is exponentially more succinct, even when it is directly encoded by tree automata. It is also shown that hardcoding counting operators produces doubly exponential larger expressions. Meyer and Stockmeyer showed in ^[28] that the equivalence of regular expressions with counting operators is EXPSPACE-complete. EXPSPACE completeness of the equivalence of regular expressions with interleaving was proven in ^[27].

In ^[4], it is described and extension of regular trees expressions with counting and interleaving, where emptiness, containment and equivalence are decidable in EXPTIME. In the current work, we identify further extensions of interleaving occurring in recursive and disjunctive fragments. Emptiness, containment and equivalence are also proved to be EXPTIME.

Regarding counting, operators introduced in ^[4], although impose occurrence bounds on children, do not restrict the consecutive occurrence of children. This contrasts with traditional semantics of counting in regular languages ^[28,19]. In the current work, by means of Presburger constraints, we identify an extension of regular tree expressions with traditional counting operators decidable in EXPTIME. In ^[15], it is introduced a polynomial algorithm for the containment of regular trees with both counting and interleaving.

The algorithm assumes two main restrictions on tree expressions: propositions occur only once, and counting can be applied to propositions only. The EXPTIME algorithm proposed in the current work overcomes these two limitations.

Counting operators on regular paths (XPath) have been studied before in ^[36,4,5]. ten Cate and Marx ^[36] showed that Presburger constraints on full regular paths lead to an undecidable formalism.

In ^[4], it was shown that when restricting only children with respect to a natural number (encoded in binary), reasoning (emptiness, containment and equivalence) is in EXPTIME. This result was extended to operators capable of constraining (w.r.t. a binary number) any regular path, including ancestors, descendants, compositions, etc. ^[5]. In this paper, we show that full Presbuger arithmetic becomes decidable on children paths. Furthermore, we set new optimal EXPTIME bounds for containment and equivalence on full (multi-directional) regular paths with Presburger constraints on children.

1.2 Outline

We introduce a modal logic for trees with fixed-points, inverse programs, and Presburger constraints in Section 2.

In Section 3, an EXPTIME satisfiability algorithm is described and proved correct. Also, it is shown that the computational cost of the algorithm is single exponential time with respect to the size of the input formula, even if the Presburger constraints are encoded in binary form.

In Section 4, we introduce extensions of regular tree languages with counting and interleaving operators.

In Section 5, regular path queries extended with Presburger constraints on children are introduced. Both extensions of regular trees and paths are shown to be succinctly captured in terms of logic formulas. This implies the satisfiability algorithm can be used as an optimal reasoning framework for regular trees and paths with counting and interleaving.

A summary together with a discussion of further research perspectives are reported in Section 6.

2.1 Syntax and Semantics

We first consider a set of propositions P, a finite set of modalities M={↓,→,↑,←}, and a set of variables X.

Definition 1 (μTLIC syntax). The set of μTLIC formulas is defined by the following grammar:

where p∈P,x∈X,m∈M,b∈N,k∈N\0,1,a∈Z\0. Numbers a, k and b are asumed to be encoded in binary. We consider the following assumptions about variable occurrences: as usual, in order to ensure the existence of fixed-points, we assume variables occurs positively, that is, under the scope of an even number of negations ^[38]; also, variables are guarded, that is, variables occur bounded (where μ is the only binding operator) and under the scope of a modal formula mϕ, or a counting formula (γ > b) ^[38]; and in order to make the least and greatest fixed points coincide, we assume variables are cycle-free, that is, variables does not occur under the scope of a modality and its converse ^[20].

In order to provide a formal semantics, we need some preliminaries. A tree structure T is a tuple P,N,R,L, where:

In the setting of XML documents (unranked trees), node labels are defined by a function instead of a relation, that is, exactly one proposition holds at each node. The satisfiability algorithm described in Section 3 can easily be adapted for this restriction (see Definition 6).

Given a tree structure, a valuation V of variables is defined as a function from the set variables X to a set of nodes V:X↦2N. For nodes N'⊆N, we write VN'x to denote the valuation V', such that V'x=N' and V'x'=Vx for x'≠x.

Definition 2 (μTLIC semantics). Given a tree structure T and a valuation V, μTLIC formulas are interpreted as follows:

We say a tree T satisfies, or is a model of, a formula ϕ, if and only if, the interpretation of ϕ under T and any valuation V is not empty, that is, ϕVT≠∅. A formula is valid, if and only if, it is satisfied by every tree. It is easy to see a formula ϕ is valid, if and only if, ¬ϕ is unsatisfiable.

The satisfiability problem for μTLIC consists in deciding whether or not a given formula is satisfiable.

We now give an intuition about the interpretation of formulas: propositions p are node labels; negation and disjunction are interpreted as the complement and the union of sets, respectively; modal formulas mϕ are true in nodes, such that ϕ holds in at least one accessible node through adjacency m, which may be either ↓, →, ↑ or ←, which in turn are interpreted as the children, right sibling, parent and left siblings relation, respectively; μx.ϕ is interpreted as the least fixed-point; a counting formula γ > b hold in a node, if and only if, the number of its children where γ true satisfy the corresponding constraint > b, respectively, for instance, p₁ + (-2)p₂ > 0 holds in nodes where the number of children where p₁ holds is greater than twice the number of children where p₂ is true.

We also use the following traditional notation:

Note that ⊺ is true in every node, hence ⊥ in none, conjunction ϕ˄ψ holds whenever both ϕ and ψ are true, [m] ϕ holds in nodes where ϕ is true in each accessible node through m, and γ ≤ b is true in nodes where the corresponding children satisfy ≤ b. Other common counting operators can also be expressed, for instance, γ = b can be written instead of (γ ≤ b) ˄ (γ > b - 1), where b > 0. Below in further sections, we also write b1#γ#b2#∈>,≤,= instead of γ#b1⋀γ#b2.

Examples

Consider for instance the following formula ψ:

where (r ≤ 2q) stands for 1r + (-2)q ≤ 0. ψ is true in nodes labeled by p, such that the number of its q children is at least twice the number of its r children. This is a common example that goes beyond the expressive power of (graded) μ-calculus and regular languages ^[16].

In Figure 2, there is a graphical representation of a model for ψ:

It is also possible to express recursive navigation, for example, consider the following formula ϕ:

ϕ is true in nodes with at least one descendant where ψ is true, that is, ϕ recursively navigates along children until it finds a ψ node.

Backward navigation may also be expressible with the help of inverse programs (converse modalities). For instance, consider the following formula φ:

φ holds in nodes with an ancestor where ψ is true, that is, φ recursively navigates along parents until it finds a ψ node. Furthermore, in contrast with other approaches without converse modalities ^[16,32], this new feature allows to count also on sibling nodes. For instance:

holds in nodes with more than 10 siblings named p.

2.2 Other Forms of Counting

We now show how several notions of counting (nominals, graded modalities and global counting) can also be expressed in terms of μTLIC formulas.

Hybrid Logics

The interpretation of nominals is a singleton, that is, nominals are formulas which are true in exactly one node in the entire model ^[9]. Now, it is easy to see that μTLIC can navigate recursively thanks to the fixed-points, and in all directions thanks to inverse programs.

Hence, μTLIC can then express for a formula to be true in one node while being false in all other nodes of the model. Nominals are then defined as follows:

where formulas Siblings(ϕ), Ancestors(ϕ), and Descendants(ϕ) are true, if and only if, ϕ is true in all siblings, ancestors, and descendants, respectively. More precisely:

Graded Logics

In modal logics, graded modalities are specialized operators for expressing numerical bounds on the occurrence of a sole formula in adjacent nodes. In the context of tree models, the numerical bounds are on children nodes ^[4]. For instance, formula ↓,kϕ holds in nodes with at least k + 1 children where ϕ is true. More precisely, given a tree structure T and a valuation V, graded formulas are interpreted as follows:

where k is a positive integer number encoded in binary. ↓,kϕ formulas are true in nodes with all but at most k children satisfying ϕ. It is then easy to see that Presburger formulas can express graded modalities, more precisely, for any tree T and valuation V, we have that:

Global Counting

Global numerical constraints, as its name suggest, are operators used to impose constraints on the occurrence of a sole formula with respect to a constant in the entire model ^[37,2,39,5].

That is, a formula ϕ>_G k holds in the entire model, if and only if, ϕ is satisfied by at least k + 1 nodes. More precisely, the interpretation of global counting formulas with respect to a tree 𝒯 and a valuation V is the following:

Note that the intended interpretation of ϕ≤_G k is the same as for formula ¬(ϕ>_G k). In ^[5], it was shown that regular path queries (XPath) with numerical constraints on any path, for instance ancestors or descendants, can be succinctly expressed by global counting formulas. It was also shown in ^[5] that global numerical constraints does not provided extra expressive power by means of a reduction to the two-way μ-calculus (without counting). More precisely, for any binary tree T (for technical convenience, binary trees are used instead of n-ary trees, there is a well known bijection between them, see Figure 3 on page 7) and valuation V, we have the following:

where r stands for the root node ¬↑⊺⋀¬←⊺, and Ckϕ counts at least k + 1 occurrences of ϕ in descendant nodes. More precisely:

μTLIC can therefore also express global numerical constraints. However, it is not hard to see that hardcoding of global numerical constraints comes at an exponential cost ^[5].

3.1 Fischer-Ladner-Presburger Trees

We first give a detailed description of the syntactic version of tree models constructed by the satisfiability algorithm.

Some preliminaries are now introduced. There is well-known bijection between binary and n-ary trees ^[22]. One adjacency is interpreted as the first child relation and the other adjacency is for the right sibling relation. In Figure 3 is depicted an example of the bijection. Hence, without loss of generality, from now on, we consider binary unranked trees only. At the logic level, formulas are interpreted as expected: ↓ϕ holds in nodes such that ϕ is true in its first child; →ϕ holds in nodes where ϕ is satisfied by its right (following) sibling; ↑ϕ is true in nodes whose parent satisfies ϕ; and ←ϕ satisfies nodes where ϕ holds in its left (previous) sibling.

For the satisfiability algorithm we consider formulas in negation normal form only.

The negation normal form (NNF) of μTLIC formulas is defined by the usual De Morgan rules and the following ones:

Hence, negation symbol ¬ in formulas in NNF occurs only in front of propositions and formulas of the form m⊺. It is also easy to see that the negation normal form of a formula has linear size with respect to the size of the formula. Also notice that we consider an extension of μTLIC formulas consisting of conjunctions, γ ≤ b, and ⊺ formulas, with the expected semantics.

From now on, we often write γ#b to denote any of the following formulas: γ > b or γ ≤ b.

We now consider a binary encoding of natural numbers. Given a finite set of propositions, the binary encoding of a natural number is the Boolean combination of propositions satisfying the binary representation of the given number. For example, number 0 is written ⋀i≥0¬pi, and number 7 is p2∧p1∧p0∧⋀i>2¬pi, (111 in binary). The binary encoding of numbers is required in the definition of counters, which are used in the satisfiability algorithm to verify counting subformulas.

Definition 3 (Counters). Given a formula ϕ and a number b > 0, a counter of ϕ set to k is defined by:

where i∈0,…logb,ϕi- is a sequence of propositions ϕⁱ occurring positively in the binary encoding of b.

Consider for instance the counter of formula ϕ set to 7:

We write (C(ϕ)=b) ∈ S, when each ϕⁱ ∈ S where Cϕ=b:=ϕi-.

A formula ϕ induces a set of counters corresponding to its counting subformulas. The bound on the number of propositions used by counters is given by K(ϕ), and it is proved in Theorem 5.

Nodes in Fischer-Ladner-Presburger trees are defined as sets of subformulas. These subformulas are extracted with the help of the Fischer-Ladner-Presburger Closure. Before defining the Closure, we define the following set of subformulas of a counting expression:

We often write ϕ_γ to denote ϕ ∈ S(γ).

Now, consider the following binary relation R^FLP on the set of μTLIC formulas, for i=1,2, ∘=∨,∧, j=0,…,logKϕ and each ϕ_γ ∈ S(γ):

Definition 4 (Fischer-Ladner-Presburger Closure). Given a formula ϕ, the Fischer-Ladner-Presburger Closure of ϕ is defined as CLFLPϕ=CLkFLPϕ, such that k is the smallest positive integer satisfying CLkFLPϕ=CLk+1FLPϕ, where for i ≥ 0:

Example 1. Consider the following formula:

This formula holds in p nodes with at least one more q child with respect to r children. In Figure 4, there is graphical representation of a ϕ-tree (Definition 7) for formula ϕ. In the definition of ϕ-trees, we use the notion of Fischer-Ladner-Presburger closure, which in the case of ϕ is defined as follows for j = 0,1,2:

We are now ready to define the lean set for nodes in Fischer-Ladner-Presburger trees. The lean set contains the propositions, modal subformulas, counters and counting subformulas of the formula in question (for the satisfiability algorithm). Intuitively, propositions will serve to label nodes, modal subformulas contain the topological information of the trees, and counters are used to verify the satisfaction of counting constraints.

Definition 5 (Lean). Given a formula ϕ, its lean set is defined as follows:

provided that p’ does not occur in ϕ , and m =, ↓, →, ↑, ←.

Example 2. Consider again the formula ϕ:=p⋀q-r>1⋀r>0. of Example 1, then for i = 1, 2 and j = 0,1,2, we have that:

Where

ψ1=μx.q⋁→x and ψ2=μx.r⋁→x.

Recall that q^j and r^j are the corresponding propositions (associated to q and r) required to define the corresponding binary encoding of numbers.

Definition 6. The set of ϕ-nodes is defined as follows:

Intuitively, a ϕ-node nϕ is defined as a subset of the lean, such that:

When it is clear from the context, ϕ-nodes are called simply nodes.

We are finally ready to define the Fischer-Lander-Presburger ϕ-trees.

Definition 7. A ϕ-tree is defined:

The root of nϕ,T1ϕ,T2ϕ, is nϕ. We often call ϕ-trees simply trees.

Example 3. Consider again the following formula ϕ:=p⋀q-r>1⋀r>0. Then T=n0,n1,∅,n2,∅,n3,∅,n4,∅,∅,∅ is a ϕ-tree, where:

ϕ-nodes n_i (i = 0,...,4) are defined from the lean of ϕ (Example 2). In Figure 4 is depicted a graphical representation of T. Notice that counters in the root n₀ are set to zero 0, that is, no proposition corresponding to counters occurs. This is because counters are intended to count siblings only. For instance, counters in n₁ are set to 3 and 1 for q and r, respectively, because there are three q's and one r in n₁ and its siblings. Counting formulas occur positively only at the root n₀, because they are intended to be true when the counters in the children of n₀ satisfy the Presburger constraints. Since n_i(i > 0) does not have children, then counting formulas occur negatively (recall the negation normal form of the input formula is also in the lean) in these nodes. Finally, notice that modal subformulas define the topology of the tree.

3.2 The Algorithm

We now define a satisfiability algorithm for the logic μTLIC following the Fischer-Ladner method ^[5,4,16,18]. Given an input formula, the algorithm decides whether or not the formula is satisfiable. The algorithm builds ϕ-trees in a bottom-up manner. Starting from the leaves, parents are iteratively added until a satisfying tree, with respect to ϕ, is found.

Algorithm 1 describes the bottom-up construction of ϕ-trees.

The set Init(ϕ) gathers the leaves. The satisfiability of formulas with respect to ϕ-trees is tested with the entailment relation ⊢. Inside the loop, the Update function consistently adds parents to previously build trees until either a satisfying tree is found or no more trees can be built. If a satisfying tree is found, the algorithm returns the input formula is satisfiable, otherwise, the algorithm returns the input formula is not satisfiable.

Example 4. Consider the formula ϕ:=p⋀q-r>1⋀r>0. The ϕ-tree T, described in Example 3, is built by the satisfiability algorithm in 5 steps. All leaves are first defined by Init(ϕ) (Definition 9): notice that n₄ is a leaf because it does not contain downward modal formulas. Once in the while cycle, parents and previous siblings are iteratively added to previously built trees, which by the second step consists of leaves only: since ↓μx.r∨→x and ↓⊺ occur in n₃, and r and ↑⊺ occur in n₄, it is clear n₃ can be the parent of n₄, analogously for n₂ and n₃, and n₁ and n₂, respectively; also it is clear that n₀ can be a parent of n₁. Notice that n₀ is the root due to the absence of upward modal formulas ↑⊺ and ←⊺. The construction of T is graphically represented in Figure 4.

We now give a detailed description of the algorithm components.

Definition 8 (Entailment). The entailment relation is defined as follows:

If there is a node n in a tree T, such that n entails ϕn⊢ϕ and formulas ↑⊺ and ←⊺. does not occur in the root of T, we then say that the tree T entails ϕ,T⊢ϕ. Given a set of trees X, if there is a tree T in X entailing ϕ,T⊢ϕ, then X entails ϕ,X⊢ϕ. Relation ⊬ is defined in the obvious manner.

Leaves are ϕ-nodes without downward adjacencies, that is, formulas with the form ↓ψ or →ψ do not occur in leaves. Also, counters are properly initialized, that is, for each counting subformula γ#b of the input formula, if a leaf satisfies ϕ_γ then C(ϕ_γ) = 1 is contained in the leaf, otherwise C(ϕ_γ) = 0, that is, no counting proposition corresponding to ϕ_γ occurs in the leaf. The set of leaves is defined by the Init function.

Definition 9 (Init). Given a formula ϕ, its initial set Init(ϕ) is defined as follows:

Notice that, from definition of ϕ-nodes, if formulas of the forms ↓⊺ and →⊺ do not occur in leaves, then neither formulas of the forms ↓ψ and →ψ do.

Example 5. Consider again the formula ϕ of Example 3. It is then easy to see that n₄ is a leaf. n₄ does not contain downward modal formulas ↓ψ and →ψ. Also, counters are properly initialized in n₄, i.e., C(r) = 1 occurs in n₄.

The Update function consistently adds parents to previously built trees. Consistency is defined with respect to two different notions. One notion is with respect to modal formulas. For example, a modal formula ↓ϕ is contained in the root of a tree, if and only if, its first child satisfies ϕ.

Definition 10 (Modal Consistency). Given a ϕ-node nϕ and a ϕ-tree T with root r, nϕ and T are m modally consistent Δmnϕ,T, if and only if, for all mψ,m-ϕ, in lean (ϕ), where m∈↓,→ and m-∈↑,←, we have that:

Example 6. Consider ϕ in Figure 4. In step 2, it is easy to see that n₃ is modally consistent with n₄: formula →μx.r∨→x is clearly true in n₃, because r occurs in n₄. In the following steps, n_i is clearly modally consistent with n_i+1.

Another consistency notion is defined in terms of counters. Since the first child is the upper one in a tree, it must contain all the information regarding counters, i.e., each time a previous sibling is added by the algorithm, counters must be updated. Counter consistency must also consider that counting formulas occurs in the parents, if and only if, the counters of its first child are consistent with constraints in counting subformulas.

Definition 11 (Counter Consistency). Given a ϕ-node nϕ and trees T₁ and T₂, we say that nϕ and T₁ and T₂ are counter consistent, written Θnϕ,T1,T2, if and only if, for the roots r₁ and r₂ of T₁ and T₂, respectively, and for all counting formulas γ#b in lean(ϕ), we have that:

Example 7. Consider the formula ϕ of Example 3 and Figure 4. In steps 2, 3 and 4, since previous siblings are added, counters for q are incremented in n₃, n₂ and n₁, respectively. In step 5, the counting formulas q-r>1 and r>0 are present in the root n₀, due to the fact that counters, in the first child, satisfy the Presburger constraints.

Update function gathers the notions of counter and modal consistency.

Definition 12 (Update). Given a set of ϕ-trees X and set of ϕ-nodes Y, the update function is defined as follow for i = 1,2:

We finally define the function root(X), which takes as input a set of ϕ-trees and returns a set with the roots of the ϕ -trees.

3.3 Correctness

We now show that Algorithm 1 is correct, and then we describe its complexity. Correctness is shown by proving that the algorithm is sound and complete. For these proofs, we first need a fixed point theorem. Proving substitution is monotone is the first step.

Lemma 1. Given a μTLIC formula ϕ, a tree structure T=P,N,R,L and a valuation V, let f:PN↦PN be defined as fS=ϕVSxT, where x is a free variable inϕ. If S⊆S', then fS⊆fS'.

Proof. We proceed by induction on the structure of ϕ. Base cases are trivial and most inductive cases are straightforward by inductive hypothesis. Recall that since we are considering only formulas in negated normal form, negation symbols ¬ occur in front of propositions and formulas m⊺ only. Consider for instance the case of conjunction ψ˄φ. By inductive hypothesis we know ψVSxT⊆ψVS'xT and φVSxT⊆φVS'xT, hence ψVSxT∩φVSxT⊆ψVS'xT∩φVS'xT, and then ψ∧φVSxT⊆ψ∧φVS'xT.

The case of the Presburger formula γ > b is more interesting. We prove this case by a second induction on the structure of γ. We distinguish three base cases, the first one is aψ>b Notice in this case a ≥ 0. By the first inductive hypothesis we know ψVSxT≤ψVSxT. It is then clear that, for any node n, ψVSxTn≤ψVS'xTn. The second base case is a1γ1+a2γ2>b, where both a₁ and a₂ are non-negative integers. This is straightforward from the first base case. The third base case is a1γ1-a2γ2>b. From the first base case, it is easy to see that for any n and i = 1,2, a1γ1VSxTn≤a1γ1VS'xTn. Hence, a1γ1VSxTn-a2γ2VSxTn≤a1γ1VS'xTn-a2γ2VS'xTn. The inductive step in γ > b is immediate from the bases cases. For the case γ ≥ b, recall that in order to ensure the fixed-point existence, variables can only occur positively, hence, variables in γ occur negatively. We then proceed analogously as in the case γ > b.

Consider now the case for μy.ψ. Now let Si⊆N be defined by gSi,S⊆Si, where gSi,S=ψVSiySxT, and Si'⊆N by gSi,S'⊆Si'. Now let S0=⋂∀iSi and S0'=⋂∀iSi'. Note that fS=S0 and fS'=S0'. By inductive hypothesis we know gSi,S⊆Si,S' for every i. Now by transitivity of the subset relation (recall gSi,S'⊆Si,S' we obtain gS0,S⊆S0', that is, there is an i such that S0'=Si. By definition of S0, it is easy to see S0⊆Si for every i. We then conclude S0⊆S0'.

We now prove the fixed point Theorem.

Theorem 1. Given a μTLIC formula ϕ, a tree structure T=P,N,R,L and a valuation V, let f:PN↦PN be defined as fS=ϕVSxT, where x is a free variable in ϕ, then the least fixed point of f is ⋂N'⊆NfN'⊆N'.

Proof. Since N is finite, then there is a finite number of Si⊆N, such that fSi⊆Si. Let S=⋂∀iSi. Since S⊆Si. for every i, and by Lemma 1, we obtain that fS⊆fSi. By definition of each S_i, we also know S⊆Si. for every i. Then by transitivity of the subset relation we obtain fS⊆Si. Now recalling that S=⋂∀iSi,fS⊆Si implies fS⊆S. Then by Lemma 1, ffS⊆fS. Then again by definition of S_i, there is a j such that fS=Sj. Since S⊆Sj, hence S⊆fS and therefore S=fS. Now since S⊆Si, for every i, it is then clear that S is the least fixed point.

A straightforward observation from the fixed point Theorem 1 is that a fixed point μx.ϕ is equivalent to its unfolding ϕμx.ϕx, that is, for any T and valuation V, we have that μx.ϕVT=ϕμx.ϕxVT.

Theorem 2 (Soundness). If the satisfiability algorithm returns that ϕ is satisfiable, then there is tree model satisfying ϕ.

Proof. Assume T is the ϕ-tree that entails ϕ. Then we construct a tree model T isomorphic to T as follows:

We now show by induction on the structure of the input formula ϕ that T satisfies ϕ.

Base cases are immediate, that is, when the input formula is either a proposition, a negated proposition or formulas with the form ¬m⊺.

Negations and disjunctions are also immediate by induction. Modal formulas mϕ are clearly satisfied by the construction of the model T and because ϕ is satisfied by induction. For counting formulas a1ψ1+a2ψ2+…+anψn#b recall by induction there is a node n in T such that Cψ1=b1,Cψ2=b2,…,Cψn=bn∈n and a1b1+a2b2+…+anbn#b.

Also in T, we know that n is the first child of a node n₀ where a1ψ1+a2ψ2+…+anψn#b is entailed. It is then easy to see that T satisfies a1ψ1+a2ψ2+…+anψn#b due to the construction described above. In the case of fixed-points, if μx.ϕ is entailed by T, then we know by the definition of the entailment relation that ϕμx.ϕx, is also entailed by T. In order to show that ϕμx.ϕx, is satisfied by T, we proceed by another structural induction on ϕ, which goes smothly since fixed-points are not considered (variables occur only in the scope of modalities or counting formulas).

Completeness proof is divided in two main steps: first we show that there is a lean labeled version of the satisfying model; and then we show that the algorithm can actually build the lean labeled version of the tree model.

Theorem 3. If there is a tree structure T satisfying a formula ϕ, then there is a Fischer-Ladner-Presburger ϕ-tree entailing ϕ.

Proof. Assume T satisfies the formula ϕ. We construct a lean labeled version T of T as follows: the nodes and shape of T are the same as in T; for each ψ∈leanϕ, if n in T satisfies ψ, then ψ is in n of T; and the counters are set in the nodes in T as the algorithm does in a bottom-up manner.

It is now shown by induction on the derivation of T⊢ϕ that T entails ϕ. By the construction of T and by induction most cases are straightforward. For the fixed-point case μx.ψ, we proceed by induction on the structure of the unfolding ψμx.ψx. That there is a finite unfolding comes from the Fixed-Point Theorem 1: μx.ϕVT=ϕμx.ϕxVT. This induction is immediate because variables and hence unfolded fixed-points occur in the scope of modal or counting formulas only.

Before proving that the algorithm builds T, we need to show that there are enough ϕ-nodes to construct T. Recall ϕ-nodes are lean subsets, and the lean is composed by propositions, modal and counting formulas occurring in the input formula, plus counters. Since counters count children nodes, we then need a bound on the number of children. For this purpose, we use a bound of an integer programming problem.

Theorem 4. ^[30] Let A be a m × n integer matrix and b a m-vector, both with entries in ℤ. Then if Ax = b has a solution x∈Nn, it also has one in 0,…,nma2m+1n.

Theorem 5. If a formula ϕ is satisfiable, then there is a ϕ-tree entailing ϕ where each node has at most an exponential number of children with respect to the size of ϕ.

Proof. Since ϕ is satisfiable, there is a ϕ-tree T entailing ϕ by Theorem 3. Recall each node in T is a subset of lean(ϕ), thus composed by propositions, modal formulas mψ and counting formulas γ#b. Notice formulas ↓ψ and γ#b are the ones enforcing child witnesses. Also notice ↓ψ are equivalent to ψ>0. We now encode this set of counting formulas as an integer programming problem in order to obtain a bound on the number of required to children: a1ϕ1+…+anϕn#b as a1xϕ1+…+anxϕn+x=b+1. when # is >, and a1xϕ1+…+anxϕn-x=b when # is ≤, where x ≥ 0. Then, each node has at most an exponential number of children by Theorem 4.

We are now ready to show that the algorithm builds the lean labeled version T of the satisfying model T.

Theorem 6 (Completeness). If there is a tree model T satisfying a formula ϕ, then the satisfiability algorithm returns that ϕ is satisfiable.

Proof. The proof proceeds by induction on the height of T. The base case is trivial. Consider now the induction step. By induction, we know that the left and right subtrees of T were built by the algorithm, we now show that the root n of T can be joined to the previously built left and right subtrees. This is true due to the following: Δ(n,n_i) is consistent with R, where i = 1, 2 and n_i are the roots of the left and right subtrees, respectively; and by Theorem 5, there are at most an exponential number of children, with respect to the size of ϕ, distinguished by counters, encoded in binary by a linear number of propositions.

Theorem 7 (Complexity). μTLIC satisfiability is EXPTIME-complete.

Proof. We first show that the lean set of the input formula ϕ has linear size with respect to the size of ϕ. This is easily proven by induction on the structure ϕ and by Theorem 5: an exponential number of children can be distinguished by a linear amount of counting propositions (recall counters are encoded in binary). We then proceed to show that the algorithm takes exponential time with respect to the size of the lean. Since ϕ-nodes are defined as subsets of the lean, it is then clear that the number of ϕ-nodes is single exponential with respect to lean size, then there is at most an exponential number of steps in the loop of the algorithm.

It remains to prove that each step, including the ones inside the loop, takes at most exponential time: computing Init(ϕ) implies the traversal of Nϕ and hences takes exponential time; testing ⊢ takes linear time with respect to the node size, and hence its cost is exponential with respect to the set of trees; and since the cost of relations of modal and counter consistency Δ_m and Θ is linear, then the Update functions takes at most exponential time. Since the μ-calculus for trees is EXPTIME-complete ^[12], then μTLIC is hard for EXTPIME, therefore, also complete.

4.1 Regular Tree Languages

We define the syntax of regular trees similarly as in ^[20,22].

Definition 13 (Syntax of regular trees). We define the set of regular tree expressions by the following grammar:

We write p instead of pϵ and we consider e⋅ϵ and ϵ⋅e to be simply e.

Following ^[22], we now give a precise semantics of regular tree expressions, but first, we define the following notation. Consider a tree structure T=P,N,R,L, recall P is a set of propositions, N a set of nodes, R is transition function among nodes forming a tree, and L is a function labeling nodes with propositions. Then, we write n,T- to denote T, with root n and children subtrees T-=T1,T2,…,Tk, that is n1,n2,…,nk∈Rn,↓, where n_i is the root of Tii=1,…,k. If we write T-∈S, we mean the composition of Ti is in set S. By the composition of a sequence of trees T-, written T1∘T2…∘…Tk, we mean the resulting tree n,T-. The composition of two sets of trees S₁ and S₂, written S1∘S2 denotes the composition of all pairs of trees in S₁ and S₂, more precisely, the trees T1∘T2, such that Ti∈Sii=1,2.

Definition 14 (Semantics of regular trees). Given a valuation V (from variables to sets of trees), regular tree expressions are interpreted as follows:

where lfp lfpVeVx_____ stands for the least fixe< point of the substitution function.

Note that there is always a least fixed poir due to the Knaster-TarskiTheorem ^[35] on fixe< points (substitution is monotone with respect to th subset ordering).

Intuitively, regular tree expressions are interpreted as sets of unranked trees: ϵ is interpreted as the empty set; p[e] denotes the sets of trees whose root is labeled by p and whose children are denoted by e; the interpretation of e1⋅e2 is the set of trees whose children are denoted by e₁ and e₂, from left to right; e₁+e₂ is interpreted as the union of the interpretations of e₁ and e₂; and let x=e____ in e is interpreted as the least fixed point. The Kleene star operator can be expressed in terms of the least fixed point, for instance, the regular tree expression pq* in Figure 1(a) can be written as follows:

We now show that regular tree expressions can linearly be translated in terms of the μ-calculus, as already shown in ^[4,5]. This implies that traditional reasoning problems, such as emptiness, containment (inclusion) and equivalence, can be efficiently expressed in terms of the satisfiability of μ-calculus formulas. Before defining a translation function from regular tree expressions to logic formulas, we define μx.ϕ___ in ϕ as a generalization (several binded variables) of the fixed point operator with the expected semantics. This generalization does not provide more expressive power, although, it is more succinct ^[4].

Definition 15. We define the following translation function from regular tree expressions to μ-calculus formulas:

where Fme is defined as follows for m∈↓,→

We say an expression e is nullable when it is a variable bounded to an expression that can be interpreted as the empty tree, as for instance ϵ+e'.

Now, consider as an example the expression pq*. This can be expressed in terms μTLIC as follows:

Theorem 8 (Reasoning on regular trees ^[4,5]). Given any two regular tree expressions e₁ and e₂, we have that for any tree T and valuations V and V':