1 Introduction

The propositional μ-calculus is a modal logic with least and fixed-point operators, expressively corresponding to the monadic second order logic MSO [⁹]. This logic is known to subsume many temporal, program and description logics such as the Linear Temporal Logic LTL, the Propositional Dynamic Logic PDL, the Computation Tree Logic CTL and ALC _reg , which is an expressive description logic with negation and regular roles [⁴]. Due to its expressive power and nice computational properties, the μ-calculus has been extensively used as a reasoning framework in a wide range of domains, such as program verification, knowledge representation and concurrent pervasive systems [⁴]. In concurrent pervasive systems, logic-based reasoning frameworks have been successfully tested in context-aware scenarios [², ³]. In this paper, we propose a reasoning (satisfiability), algorithm for the μ-calculus with converse, where formulas are interpreted over finite unranked tree models. The algorithm is based on a depth-first search, and its complexity is optimal, that is, exponential time with respect to the input formula. We also describe an implementation of the algorithm.

XPath is the standard query language for semi-structured data (XML). This query language also takes an important role in many XML technologies, such as, XProc, XSLT and XQuery. Although the full XPath query language is known to be undecidable [¹⁵], the μ-calculus with converse has been successfully used as a reasoning framework for the navigation core of XPath, known as regular path queries [⁵, ⁷]. We also describe a logic characterization of regular path queries in terms of μ-calculus formulas. Since the logic is closed under negation and the proposed algorithm is optimal, our implementation can be used for optimal standard reasoning (emptiness, containment and equivalence), of regular path queries.

2 The μ-Calculus on Trees

In this section, we introduce the μ-calculus with converse. Formulas are interpreted over finite unranked trees. The alphabet is considered by two sets, PROP and MOD, where PROP is a set of proposition and MOD={1,2,3,4}, is the set of modalities.

Definition 1 (Syntax). The set ofμ-calculus formulas is defined by the following grammar:

where p is a proposition, m a modality, and X is a variable.

We assume variables can only occur bounded and in the scope of a modality.

Formulas are interpreted as subset nodes in unranked trees. Propositions are used as labels for nodes, negation (¬), is interpreted as set complement, disjunctions are interpreted as set union. We write ϕ∧φ instead of ¬(¬ϕ∨¬φ).

Modal formulas 〈m〉ϕ holds in nodes where there is an m-adjacent node supporting ϕ. The least fixed-point is intuitively interpreted as a recursion operator.

We now present the tree structures defined in style of kripke.

Definition 2 (Tree structure). A tree structure, or simply a tree, is a tuple (N, Rm, L) where:

we give a formal description of the semantic of a formula, where Var is a set of fixed-point variables, 2N is the power set of nodes:

sust(V,K,X,φ):=V′(Y)=V(Y) where Y≠X.

sust(V,K,X,φ):=V′(Y)=〚φ〛VK where Y=X.

Definition 3 (Semantics). Consider a tree K and a valuation V:Var↦2N, where Var is a set of variables. The semantics of the formula is defined as follows:

A formula ϕ is satisfiable, if and only if, there is a tree (model), such as the interpretation of ϕ over the tree is not empty, that is 〚ϕ〛VK≠∅.

Example 1. In Figure 1, there is a graphical representation of tree model. Consider for instance the following formula:

This formula selects nodes names p1 with a child named p2. In Figure 1, this formula holds in n1. Recursive navigation can be expressed with the fixed-point:

This formula holds in a p1 node with a descendant p3 at node n4 and a child p2 at node n2. In Figure 1, this formula also holds in n1.

3 Fischer-Ladner Trees

The satisfiability algorithm builds a syntactic version of tree structures, called Fischer-Ladner trees [⁶], where nodes are sets of subformulas. In this Section, we define this notion of trees.

There is a well-know bijection between n-ary and binary trees: one relation is for the first-child (parent), and the other for the following (previous) sibling. In Figure 2, there is a graphical representation of this bijection. Hence, without loss of generality, for technical convenience, we work on binary trees. Also, modal formulas should be re-interpreted:

We also consider formulas in negation normal form only: negation only occurs in front of propositions and formulas 〈m〉⊤, where ⊤ stands for p∨¬p. We then define the following function.

We then define the negation normal form of a formula, as the resulting formula of replacing negations ¬φ with nnf(φ).

Some notions are required before introducing Fischer-Ladner trees.

Definition 4. We define a binary relation RFL on formulas with i=1,2:

Definition 5 (Fischer-Ladner Closure). Given a formula φ , the Fischer-Ladner closure of φ is defined as FL(φ)=FL(φ)k, where k is the smallest positive integer satisfying FL(φ)k=FL(φ)k+1, where:

We now define the lean set for the syntactic nodes. This set is intuitively composed by the propositions and modal subformulas of the input formula. The propositions are used to name the nodes, and modal subformulas give the topological information of candidate trees.

Definition 6 (Lean). Given a formula φ and a proposition p′ not occurring in φ , the lean of φ is defined as follows for all m∈MOD :

Example 2. Consider the following formula:

The lean of φ is defined as follows:

We are now ready to define nodes in Fischer-Ladner trees.

Definition 7 (Nodes). Given a formula φ , a node in Fischer-Ladner trees is defined as subset of lean(φ) , such as:

Example 3. Consider the same formula and corresponding lean as in Example 2. We then define the following nodes:

And we now finally define Fischer-Ladner trees.

Definition 8 (Fischer-Ladner Tree). We inductively define Fischer-Ladner trees as follows:

when clear from context, we often write simply a tree instead of a Fischer-Ladner tree.

Example 4. Consider the nodes in Example 3. We then define the following tree:

Figure 3, ilustrates the tree.

4 Depth-First Search Based Satisfability Algorithm

In this section we describe satisfiability algorithm of μ-calculus based on depth-first search. The Algorithm 1 decides whether a formula is satisfiable or unsatisfiable. In the main function the algorithm creates the required nodes. Then the nodes are iterated. The satisfiability algorithm builds the tree starting from the node that satisfies the formula. This node is used as a candidate and from it begins the construction of the tree. Once the node is selected, the algorithm enters the search function.

The Algorithm 2, shows the search function. When the formula is p,⊤,¬p or ¬〈m〉⊤, then, the algorithm evaluates the satisfiability of the node and returns true. If it contains fixpoint, then, algorithm makes its expansion and called the function search. The cases for disjunction and conjunction, the algorithm invokes the search function on both sides. When the formulas have the form of modality, it searches the next node. The formula can contain modalities 〈1〉,〈2〉,〈3〉 or 〈4〉.

The current node is deleted from the list of nodes, the algorithm obtains a list of the following nodes with the next function, the node list is iterated and the tree is updated. It is called the search function, if it returns false, thus, the next node is removed from the tree. Each time a node is added, it is passed to the status used and it can not be reused in subsequent levels of the tree, avoiding in such a way to build an infinite tree. If there are not more nodes to search, then the algorithm returns false. The algorithm ends when all nodes have been traveled or the tree is built.

Now we define when a formula is satisfiable.

Definition 9. Given a formula ϕ and a node n , we define the satisfiability n⊢ϕ as follows:

The Δm function is responsible for verifying the union of one node with respect to another node through a modality m. Where n′ is possible to join node, n1 the current node, m are modalities 〈1〉 or 〈2〉, m¯ are reverse modalities 〈3〉 or 〈4〉 and 〈m〉φ modal formula.

Definition 10. Given two nodes n , n′ and formula φ , it is determined that these nodes are consistent with respect to the formula Δm(n,n′) where m∈{1,2,3,4} , if and only if modal formulas 〈m〉φ1,〈m¯〉φ2∈lean(φ) , it states the following:

Example 5. Given the formula φ=〈1〉〈1〉¬p1∧〈1〉¬p1∧¬p1∧μX.(p1∨〈1〉X)∧〈2〉p2∧p3. used in Example 2 the unions are the following:

where n1={p′,〈1〉μX.(p1∨〈1〉X),〈1〉¬p1,〈1〉〈1〉¬p1,〈2〉p2,p3} , n2={p′,〈1〉¬p1,〈1〉μX.(p1∨〈1〉X)} , n3={p′,〈1〉μX.(p1∨〈1〉X)} , n4={p1} and n5={p2} .

These nodes are consistent because the child nodes contain the witnesses of the modal formulas.

The next function obtains the set of nodes subsequent to a candidate node. This function is defined by a triplet of elements (n,〈m〉φ,Y). Where n is the current node, 〈m〉φ modal formula, Y the set of nodes unused and T is tree.

Definition 11 (Nodes). Given a tree T , the nodes function is defined as follows:

A node Tn is denoted as follows:

Definition 12 (SubTree). The subtree T′ of a given tree T(T′⊆T) is defined as follows:

Definition 13 (Root). The root(T) function takes the tree as input and returns a node root of the tree.

Definition 14 (neighborhood). Given a tree T and node n , the neighborhood function obtains adjacent nodes. Considering that exist trees T′, T1 and T2 :

Definition 15 (Delete). Given a tree T and node n , the node is removed of tree, the Delete function is defined as follows:

where n≠n′.

Definition 16 (Update). Given a tree T, two different nodes n and n′ and a modality m, the Update function is defined as follows:

When n′∉nodes(T),

-update((n,T1,T2),n,n′,3)=(n′,(n,T1,T2),∅),

-update((n,T1,T2),n,n′,4)=(n′,∅,(n,T1,T2)),

-update((n,∅,T2),n,n′,1)=(n,(n′,∅,∅),T2),

-update((n,T1,∅),n,n′,2)=(n,T1,(n′,∅,∅)),

-update((n″,T1,T2),n,n′,m)=(n″,update(T1,n,n′,m),update(T2,n,n′,m)),

-update(∅,n,n′,m)=∅.

When n′∈nodes(T),

-update(T,n,n′,m)=T,

where m is modality, T is Tree and n is a node.

Definition 17 (Next). Given two nodes n,n′ and a formula. We say that, these nodes are consistent modally with regard to formula, it is denoted by Δm(n,n′), if and only if, for all formulas 〈m〉ϕ,〈m¯〉ϕ and T is tree, the next function is defined as follows:

where m={1,2,3,4}.

Theorem 1 (Soundness). If the satisfiability algorithm returns true for the input formula ϕ , then there is tree model satisfying ϕ:

Proof. By induction on the formula ϕ. If the algorithm returns true, we know that there is a tree T=(n,T1,T2). We will now construct a tree model K(T)=(N,R,L).

We now show that K(T) satisfies ϕ by induction.

When the formula ϕ has the form: p,⊤,¬p or ¬〈m〉⊤, then, the algorithm stops and returns true. Hence, there exists a node n to consider. The tree model is T=(n,∅,∅) and T⊢ϕ. From Definition 9 of n⊢ϕ, we know that ϕ is satisfiable. The tree structure is K=({n},∅,L(n)). Thus, in the case p then p∈L(n). Now in the case ¬p where p∉L(n). For the case ⊤ is valid in the node without restriction. Finally, in the case ¬〈m〉⊤ is valid when 〈m〉⊤∉n. Therefore ϕ is satisfied by K(T).

The cases for disjunction and conjunction are also easy. Thus, if it is a disjunction φ1∨φ2, then where at least one φ1 or φ2 is satisfied by n⊢φ1 or n⊢φ2. The structure tree is T=(n,T1,T2) and T⊢φ1∨φ2. Now by induction K(T)⊨φ1 or K(T)⊨φ2, thus K(T)⊨φ1∨φ2. Therefore φ1∨φ2 is satisfied by K(T).

In the case of a conjunction φ1∧φ2, both φ1 and φ2 are satisfied by n⊢φ1 and n⊢φ2 hence T⊢φ1∧φ2, then by induction K(T)⊨φ1 and K(T)⊨φ2. Therefore φ1∧φ2 is satisfied by K(T).

The case where ϕ is a modal formula 〈m〉φ. As we know that n′⊢φ, thus there is a subtree T′ of T, then we apply induction in T′⊢φ and K(T′)⊨φ, where we define K1=(N′,R′,L′), hence K0=(N,R,L) where N=N′∪{n},R=R′∪{(n,m,n′),(n,m¯,n′)} and L=L′∪{(n,p)|n⊢p}. Therefore 〈m〉φ is satisfied by K(T).

The case for ϕ is a fix-point formula μX.φ. Let us recall that there exists an expansion equivalent in fixed-point formula: 〚μX.φ〛VK=〚φ[μX.φ/X]〛VK shown in the article [¹⁴].We know that there is a tree T⊢φ[μX.φ/X]. Recall variables can only occur in the scope of a modality. Therefore, we remember that this form only exists where the formula is ψ1∨ψ2, ψ1∧ψ2 or 〈m〉ψ but they were shown above.

Theorem 2 (Completeness). If a formula ϕ is satisfiable, then the algorithm returns true.

Proof. By assumption, we know that given a tree structure K that satisfies a formula ϕ. The algorithm builds a tree that satisfies ϕ and return true. This proof is divided in two steps. First we build a tree of ϕ with K structure and we show how a tree T satisfies ϕ. Second step we show how a tree can be built where ϕ is satisfied.

We will now construct a K structure T(K)=(n,T1,T2).

We now show that T(K) satisfies the formula ϕ.

We consider a tree structure satisfying the formula ϕ. By induction on a formula ϕ. When the formula ϕ has the form: p,⊤,¬p or ¬〈m〉⊤, these are the base cases. The tree structure satisfying ϕ is a T=(n,∅,∅) where n is a candidate node. In the case of p is in the lean, the T in T(K) satisfies p. In the case when ϕ is ⊤, then any T is fine. Now in the cases where ϕ is ¬p and ¬〈m〉ϕ, none of them belong to the lean. Thus ϕ is ¬p and ¬〈m〉ϕ must satisfy the tree T, thus T(K)⊨ϕ.

The cases for disjunction and conjunction are also easy. Thus, if it is a disjunction φ1∨φ2, now by induction T(K)⊨φ1 or T(K)⊨φ2, thus T(K)⊨φ1∧φ2. otherwise , if it is a conjunction φ1∧φ2, now by induction T(K)⊨φ1 and T(K)⊨φ2, thus T(K)⊨φ1∧φ2.

The case where ϕ is a modal formula 〈m〉φ. Then we know that 〈m〉φ is in the lean, according to T(K), then φ corresponding the corresponding node n′ in T(K) of n contains 〈m〉φ, hence T(K)⊨〈m〉φ.

In the case when ϕ is a fix-point formula μX.φ. Let us remember that there is an equivalent expansion in fix-point formula: 〚μX.φ〛VK=〚φ[μX.φ/X]〛VK. We recall that X variables can only occur in the scope of a modality. Therefore, we remember that only exist this form where the formula is ψ1∨ψ2, ψ1∧ψ2 or 〈m〉ψ and they were shown above. The variables in fix-point occur only in the modalities, thus they never occur in this case.

We consider the tree structure K satisfying a formula ϕ, and we follow by induction on ϕ. The base case is easy, since K is (n,∅,∅). In the first case all nodes are created. Then ϕ enter to the search function and is evaluated in the base cases. When the formula ϕ has the form: p, ⊤, ¬p or ¬〈m〉⊤ it is immediate. In the cases of disjunction and conjunction the search function is called with each subformula. The case for ϕ is a fix-point formula μX.φ, it calls the search function with equivalent expansion in fix-point formula. When ϕ has the form 〈m〉φ, the formula is evaluated in ϕ=〈m〉φ and called the next function, where the following nodes are searched. After that, the tree K is updated to the next node calling the update function. We know that the update function generates the relationship of two nodes and updates the tree. Then by induction, we know the tree T(K) has been produced by the algorithm in search function. Therefore T(K) is built by the algorithm.

Theorem 3 (Complexity). The satisfiability algorithm is in EXPTIME.

Proof. Notice that, the lean has linear size K with respect to the formula ϕ size. Notice the Nϕ size is exponential with respect to the lean size. The next step is to initialize the tree. Hence, the first loop is clearly at most exponential. The next step is n⊢ϕ, then the cost is linear. Assigning node to the tree (T←(ni,∅,∅)) is also a step. Now the search function has distinct cases. In the case where ϕ is p is a step, the next step p∈n the cost is linear. Now in the case where ϕ is ¬p is a step, the next step is ¬p∉n, then the cost is linear. In the case where ϕ is ¬〈m〉⊤ is also a step, the next step is 〈m〉⊤∉n, then the cost is linear. Finally when the case where ϕ is ⊤ is a step. In the case where the formula is ϕ1∨ϕ2 and ϕ1∧ϕ2, thus search function is k-steps until the formula expands and ends in a base case.

The formula is expanded when it obtains a subformula of main formula. When the formula is 〈m〉ϕ is a step. Besides, when it removes the node from the list (Y←Y\{n1}), the cost is at most exponential time because it iterates all the set of nodes. The next function has an exponential time cost. This function obtains nodes that can join and the nodes are used in the next cycle. The update function perform a assignation of tree, the assignment is a step. But the search for Update function in the tree is at most exponential. The next step is to expand the formula and get the modal formula. Then call the search function.

Now if the search function return false, the tree is modified with the Delete function. The Delete function reassigns the tree, this assignment is a step but the search in the Delete function in the tree is at most exponential. Now in case where the formula is μX.ϕ, then μX.ϕ is exponential and limits the number of nodes [¹⁰]. However if the search function returns false, the algorithm generates possible branches. Hence, the branch created has backtracking when the search function returns false. Consequently, the algorithm can be generating false branches. Hence the number of branches is: (1/2)n(n+1). Hence, the tree size is at most exponential.

5 Regular Path Queries

In this section, we introduce the XPath queries. XPath language is used to navigate XML documents.

Definition 18 (Syntax). The set of queries is defined as follows.

ϱ:=⊤|α|p|α:p|ϱ/ϱ|ϱ[β]β:=β∨β|¬β|ρρ:=ϱ|/ρ|ρ∩ρ|ρ∪ρ|ρ\ρα:=self|child|parent|descendant|desc−or−self|desc−or−self|ancestor|anc−or−self|foll−sibling|prec−sibling|following|preceding

Definition 19 (XPath semantics). The semantics of XPath queries is defined by function 〚⋅〛⋅ with respect to a structure K , to pairs of nodes in K.

where the function[〚⋅〛]⋅is used for the qualifiers or filters and it is distinguished from the interpretation of the path〚⋅〛⋅.

Example 6. Let us consider the following example:

where we select the descendant node with the proposition q. The path is evaluated from the root and find the node with proposition q. Another example, let us consider the following path:

The path select the descendant q and this contains a parent p.

Figure 4 shows the query for two previous examples. Then, the query /descendant:q select the n3 and the query descendant:q/parent:p select the n2.

Definition 20 (Reasoning problems). We define the containment, emptiness and equivalence in the context of regular path queries.

Regular queries can be expressed as μ-calculus formulas. Now we show the characterization of the formulas Xpath to terms of the μ-calculus inspired by [⁷].

Definition 21 (XPath queries into μ-calculus formulas). Given a context formula C, the translation M from regular path queries into μ-calculus is defined as follows:

Example 7. We consider the following path showed in Example 6:

then, the query is translated as follows:

Another example is the following path:

then, the query is translated as follows:

Now the formula F1 is passed as context C to formula F2.

Now we show reasoning problems with XPath queries. The problems are solved using the logic as a reasoning framework, and they are emptiness, containment and equivalence of queries.

Theorem 4. (Query reasoning [⁷]). For any XPath queries ρ,ρ1,ρ2, tree K and valuation V, the following holds:

We now show a set of queries to be evaluated in reasoning problems.

These experiments were performed to determine the containment of a query. In [⁷] an algorithm based on breadth-first search in the style of Fischer-Ladner is presented. They present results of reasoning problems such as the containment, emptiness and equivalence of a query. We now show experiments similar to those presented in article [⁷]. They are similar with respect to lean size. Where lean is the delimiter of the complexity of the algorithm. We used Xpath queries in non-abbreviated syntax. In Table 1, we observe the results obtained by the algorithm based on a depth-first search. The results presented by these authors are very similar to ours. Time is given in milliseconds. In each experiments the context C is ⊤.

This algorithm was implemented in Java language. The experiments were executed on the computer with the following features: Windows 8 operating system, AMD processor A6 2.7GHz., 8Gb of RAM.

This algorithm is found online at the following url¹.