Abstract
This study proposes to adopt a novel tableau reasoning algorithm for the description logic with semantics based on a finite residuated De Morgan lattice. The syntax, semantics, and logical properties of this logic are given, and a sound, complete, and terminating tableaux algorithm for deciding fuzzy ABox consistency and concept satisfiability problem with respect to TBox is presented. Moreover, based on extended and/or completionforest with a series of sound optimization technique for checking satisfiability with respect to a TBox in the logic, a new optimized ExpTime (complexityoptimal) tableau decision procedure is presented here. The experimental evaluation indicates that the optimization techniques we considered result in improved efficiency significantly.
1. Introduction
The fuzzy DL (Description Language) over lattice is a generalization of the crisp DL that uses the elements ofas truth values, instead of just the Boolean true and false. Different to fuzzy DLs, elements of the rational unit interval provided a membership degree semantics for their concepts;is further generalized to address qualitative uncertainty reasoning (by relying, e.g., on {false, likelyfalse, unknown, likelytrue, true}) and quantitative uncertainty reasoning (by relying, e.g., on (for an integer, in increasing order [1])).
Several attempts have been made at using fuzzy set semantics [2], but only a limited kind of semantics over lattices is considered, where conjunction and disjunction are interpreted through the lattice operators meet and join, respectively. Borgwardt and Peñaloza considered the fuzzy logic with semantics based on a finite residuated lattice [3] and a complete De Morgan lattice equipped with a tnorm operator [4]. Further, Borgwardt and Peñaloza analysed the consistency and satisfiability problems in the description logic with semantics based on a complete residuated De Morgan lattice [5] and showed that concept satisfiability in under this semantics is undecidable, in general, even if a very simple class of infinite lattices is restricted.
In this paper, we extend the more general description logic , whereis a complete De Morgan lattice equipped with a tnorm operator. The fuzzy description logic  is a generalization of the crisp description logic that uses the elements of as truth values instead of just the Boolean true and false. We study fuzzy variants of the standard reasoning problems like concept satisfiability and consistency with general concept inclusions (GCI) in this setting and proved that with the help of a tableauxbased algorithm satisfiability becomes decidable and the ExpTime complete if is required to be finite.
The main contributions of this work can be highlighted twofold as follows.(i)It presented a novel tableau reasoning algorithm for the description logic with semantics based on a finite residuated De Morgan lattice.(ii)By combining a series of optimization techniques that can be applied to fuzzy DL , our framework reduces the search space of the tableau algorithm more significantly to ExpTime complete.The paper is organized as follows. Section 2 introduces the syntax and semantics of the fuzzy description logic over lattices and discusses some logical properties of the logic. In Section 3, we give a detailed presentation of the reasoning algorithm for deciding the consistency and satisfiability of a ABox, provide the proofs for the termination, soundness, and completeness of the procedure, and address the computational aspect of reasoning in it. In Section 4 we extend the previous results by adding a wide variety of optimisations to achieving a high level of performance on tableau reasoning in expressive description logic. Our empirical evaluation shows that the proposed optimisations result in significant performance improvements in Section 6. Finally, future research issues are outlined in Section 7.
2. The Logic 
In this section we introduce a residuated De Morgan lattice extension of the DL, creating the language. The fuzzy description logic, which is the extension of [4] and [5], with the number restrictions constructor. And is a generalization of the fuzzy description logic.
Definition 1 (syntax). Letandbe pairwise disjoint sets of concepts and role, and let, be a set of transitive role names. The complex roles are.complex concepts are defined inductively by the following production rule, whereandis a complex role:
A complex roleis transitive if eitheror inverse ofbelongs to.
Definition 2 (semantics). For a residuated De Morgan lattice, an interpretation is now a pair , whereis the domain for the classical case andis an interpretation function mapping: every concept name a function and every role name a function. Anassertion is an expression , a role assertion of the form, whereis a concept,is a complex role,are individual names, , and.
A finite set of assertions and terminological axioms is called a Knowledge Base (KB). A fuzzy knowledge baseconsists of a finite set of axioms organized in three parts: a fuzzy ABox (axioms about individuals), a fuzzy TBox (axioms about concepts), and a fuzzy RBox (axioms about roles); that is, . An interpretation satisfies (is a model of) a KB if and only if satisfies each element in .
An interpretation satisfies the concept definition if and only if for all ,. A general TBox is a finite set of GCIs.satisfies the GCI if and only if, for all ,. An acyclic TBox is a finite set of concept definitions such that every concept name occurs at most once in the lefthand side of an axiom, and there is no cyclic dependency between definitions [6].
The complete set of semantics is depicted in Table 1. Particularly notice that existential and universal quantifiers are not dual to each other, and the implication constructor cannot be expressed in terms of the negation and conjunction.
Next, we will pay more attention to the problem of deciding satisfiability of a concept, especially computing the highest degree with which an individual may belong to a concept.
Definition 3 (satisfiable). Letbe concept descriptions, a TBox, and . is satisfiable with respect to if there is a model of such that. The best satisfiability degree forwith respect to is the largest such that is satisfiable with respect to .
The notion of witnessed model for fuzzy DLs was first introduced by Hájek [7]. Witnessed models of fuzzy predicate logic are models in which each quantified formula is witnessed; that is, the truth value of a universally quantified formula is the minimum of the values of its instances and similarly for existential quantification (maximum) [8].
Definition 4 (witnessed model). Let. A model I of an KBis witnessed if for every, every role , and every concept there are
The semantics of the quantifiers require the computation of a supremum or infimum of the membership degrees of a possibly infinite set of elements of the domain. Reasoning is usually restricted to witnessed models in order to obtain effective decision procedures [7]. Sinceis finite, we always have the witnessed model property for some. On the basis of of [6], we have deduced Lemma 5.
Lemma 5. If the cardinality of the largest antichain of L is n, thenhas the nwitnessed model property.
For simplification of the algorithm description, we consider. The algorithm and the proofs of correctness can easily be adapted for any other.
3. Tableau Algorithm for  DL
We assume that all concept descriptions are in negation normal form (NNF); that is, negation appears only in front of concept names. We will also abuse our notation by saying that a TBox is in NNF if all the concepts occurring in are in NNF. Moreover, we prove the decidability of the DL by providing a tableaux algorithm for deciding the standard DL inference problems.
3.1. Tableau
Since most of the inference services of fuzzy DLs can be reduced to the problem of consistency checking for ABoxes [9], here we discuss the approaches to deciding consistency of fuzzy DLs over finite residuated De Morgan lattices in the presence of GCIs. The algorithm we present can be seen as an extension of the tableau presented in [5] and is inspired by the wellknown tableau algorithm for [10], which is the basis for several highly successful implementations.
It is assumed thatis finite, and we can accordingly restrict reasoning towitnessed models. In the lattice ,we employ the symbolsandas a placeholder for the inequalitiesand and the symbol as a placeholder for all types of inequations. Furthermore we employ the symbolsand to denote their reflections.
Definition 6. For a fuzzy concept, we will denote bythe set that containsand it is closed under subconcepts of. The set of all subconcepts of concepts that appear within an ABox is denoted by sub(). Letbe the set of roles occurring in and together with their inverses, andis the set of individuals in . A fuzzy tableauforis a quadruple in, such that (i) is a nonempty set of individuals (nodes),(ii):maps each element and concept, that is, a member of, to the degree of certainty of that element to the concept,(iii):maps each role ofand pair of elements to the degree of certainty of the pair to the role,(iv): maps individuals occurring into elements in.
For all,, , and,satisfies the following. (1),for.(2)If, then.(3)If, thenand.(4)If, thenand.(5)If, thenand.(6)If, thenand.(7)Ifandis conjugated with, then.(8)Ifand is conjugated with, then .(9)If, then there exists such that and, then.(10)If , then there existssuch that and, then .(11)If, andis conjugated with, for somewith Trans(), then.(12)If , andis conjugated with, for somewith Trans(), then.(13)if.(14)Ifandthen,.(15), then.(16), then.(17), then , conjugated with, .(18) , then , conjugated with,.(19)There do not exist two conjugated triples in any label of any individual.(20)If, then.(21)If, then.(22)If, then .
Lemma 7. AnABox is consistent with respect to if and only if there exists a fuzzy tableau for with respect to .
Proof. Similar to that of Lemma 6.5 of [11], here gives the proof of the Lemma 7. For the direction if = is a fuzzy tableau for an ABox with respect to , we can construct a fuzzy interpretation = that is a model of . Consider the following:
For all role,
whereis a binary fuzzy relation defined asfor all, andrepresents its supmin transitive closure [12]. The proof of this property is quite technical and omitted here. From all above properties, the interpretation of individuals and roles implies that satisfies each assertion in inductively.
3.2. Constructing a  Tableau
Like most of the tableaux algorithms, our algorithm works on completion forests rather than on completion trees which is applied in work [5]. As pointed out in [13], that is because an ABox might contain several individuals with arbitrary roles connecting them.
Definition 8 (completion forest). A completion forest foris a collection of trees whose distinguished roots are arbitrarily connected by edges. Each nodeis labelled with a set. Each edgeis labelled with a set, whereare roles and its inverse occurring in . A completion forest comes with an explicit inequality relationon nodes and an explicit equality relationwhich are implicitly assumed to be symmetric. Given a completion forest, If nodesandare connected by an edgewithoccurring in, thenis called anofandis called anof. A nodeis a positive (resp., negative) successor (resp., predecessor or neighbour) of.
A node is blocked if it is either directly or indirectly blocked. It is indirectly blocked if itspredecessor is either directly or indirectly blocked. A nodeis directly blocked if and only if none of its ancestors are blocked, and it has an ancestorsuch that.
A node is said to contain a clash satisfying one of the conditions such that if and only if there exist two conjugated triples in, or if and, are root nodes, contains two conjugated triples. Table 2 shows all the entries under which condition the row column pair ofconstraints is aconjugated pair(e.g.andis a conjugated pair as).
The calculus is based on a set of constraint propagation rules transforming a setinto satisfiability preserving setsuntil either one ofcontains an inconsistency (clash), or someis completed and clashfree; that is, no rule can further be applied toandcontains no clash (indicating that froma model ofcan be built).
is then expanded by repeatedly applying the rules from Table 3. The notationdenotes either the roleor the role returned by, and the notation denotes any role that participates in such a triple.
The completion forest is complete when for some node contains a clash, or none of the completion rules in Table 3 are applicable. The algorithm is correct in the sense that it produces a clash if and only if Σ is inconsistent. The expansion rules are based on the properties of the semantics presented in Definition 6.
3.3. Soundness and Completeness of the  Tableaux Algorithm
Lemma 9 (termination, soundness, completeness). For a given KB: (i)the tableau algorithm terminates;(ii)if the expansion rules can be applied tosuch that they yield a complete completionforest such thathas a solution, thenhas a model;(iii)ifhas a model, then the expansion rules can be applied in such a way that the tableaux algorithm yields a complete completion forest forsuch thathas a solution.
3.4. Computational Complexity of the Tableau Algorithm for 
We have described a tableau procedure for reasoning in. Due to the tableau rules are nondeterministic, every application of expansion rules to a termination after at most exponentially many rule applications. So according to the theorem in [5] that the tableaux algorithm is NExpTime complete, we get the following proposition deciding the computational complexity of the tableau algorithm for.
Proposition 10. The concept satisfiability checking problem in with respect to witnessed models can be decided in NExpTime.
Proof (sketch). It is assumed that has thewitnessed model property for some, the completion forest has to generatedifferent successors for every existential and universal restriction to ensure that the degrees guessed for these complex concepts are indeed witnessed by the model. As stated by Table 1, we have to introduce individuals and values , , which satisfies or , respectively. In the following we let be the number that occurs in a number restriction, and let be the number of different lattices appearing in .
Following [14] we set ; in the meantime, we let ,,,, and. Then due to the proof of Lemma 6.9 in [11] and by the addition of the number of different lattices appearing in : a completion forest for becomes no longer thanand that the outdegree is bounded by. Consequently, the algorithm will construct a completion forest with no more than nodes.
For fuzzy description logics with semantics based on complete residuated De Morgan lattices (e.g.,), strong satisfiability with respect to general TBoxes is undecidable for some infinite lattices while, for finite lattices, decidability is regained [5]. If one considers the without terminological axioms, concept satisfiability is ExpTime complete as in the crisp case [15]. The problem with respect to general TBoxes becomes ExpTime complete matching the complexity of the crisp case, though arbitrary (finite) lattices and tnorms are allowed [4]. Besides, strong concept satisfiability is in NExpTime .
When we consider finite De Morgan lattices, then satisfiability problem can be effectively decided. We guess that the computational complexity of it can be improved to ExpTime either by an ABox partitioning [16] or with the help of global caching and other techniques [17].
4. Optimization Techniques Employed in Tableau Algorithm for 
From Proposition 10, it is obvious that the theoretical complexity of the tableau reasoning algorithm for is 2NExptime, which is too expensive for a reasoner to deal with. So we plan to investigate some optimizations [18] developed for tableaux algorithms for crisp DLs, which can be transferred to our setting to reduce the search space created by the choice of lattice values. By using these techniques, a theoretically expensive computation could be converted to an equivalent of practically lower complexity.
In this section we describe in detail the optimisation techniques employed in tableau algorithm for. Not only focusing mainly on novel techniques and significant refinements and extensions of previously known techniques such as global caching, we also apply some simple but often very effective optimisations to our implement. First of all, we perform some preprocessing optimisations directly on the syntax of the input. Then in virtue of the ideas of both backjumping and global caching, we investigate an optimized tableaubased reasoning algorithm and prove its ExpTime complete.
4.1. Preprocessing Optimisations
In case of obvious clash detection or cycle via concept names, preprocessing optimisations (e.g., absorption or told cycle elimination) can lead to important speedup of the subsequent reasoning process. These optimisations serve to preprocess and simplify the input into a form more amenable to later processing [18]. Furthermore, these optimisations are not specific to tableaubased fuzzy reasoners and may also be useful with other kinds of fuzzy DL reasoners. Herein on the basis of, we apply two striking optimizations techniques to our design and implement.
4.1.1. Partition Based on Connectivity
Partition based on connectivity is a quite effective optimization technique to boost up the performance of reasoning, which can be applied to any fuzzy DL without nominals independently of the fuzzy operators used to provide the interpretations [17]. Termination of the expansion of the completion forest is a result of the properties of the expansion rules in Table 3, and a tableau expansion rule can either add (i) a new neighbour node to the node of examination, (ii) new membership triples in this node, or (iii) new membership triples to neighbouring nodes. The expansion rule will examine the different ways that the tableau expansion rules affect this completion forest, with the respect of different connectivity circumstances. Inspired by the work in [17], we have the following definitions.
Definition 11. Let, , , . The connection relation between two individuals, in an ABox is inductively defined through role :
Note thatmay be run into an iterative process for connecting indirectly. The individuals in the ABox may be divided into one or more individual groups. Then individual group is partitioned into one or more independent subsets called Assertion Groups () [16]. For instance, two assertionsandare in the same ifis directly or indirectly inferred from(through the application of completion rules), oranddiffer only in terms of their certainty values and/or conjunction and disjunction functions. Each group is composed of individuals that are connected to each other through role assertions.
Definition 12. We denotewith the partition of the ABox that contains only connected individuals in
Proposition 13. It holds that(1),(2), for each pairsuch that,(3) is consistent with respect to a TBox if and only if each is consistent with respect to a TBox .
Partition based on connectivity optimization technique has several advantages. First, it is of polynomial complexity and it can be applied to any fuzzy DL. In addition, If any is found to be inconsistent, this implies that the whole is inconsistent. A related benefit is to more precisely identify the assertions that cause the inconsistency. Finally, the speed of solving a few small constraint sets would be faster than solving one large constraint set.
4.1.2. Dealt with TBox Axioms
If dealt with axioms of TBox naively, which maybe lead to a serious degradation in reasoning performance, as each such axiom would cause a disjunction to be added to every node of the completion forest, leading to potentially enormous amounts on nondeterministic expansion [18].
Given, with, testing the satisfiability ofleads to the construction of a completion forest containingnodes, then there aredifferent ways to apply the  and rules to the resultingcopies of, which leads to the explosion in the size of the search space. Fortunately, some notable works of optimisations known as lazy unfolding and absorption had been used to identifying these problems [19]. Herein we choose lazy unfolding optimisation to address this issue. Due to the limitation of the paper, detailed definition of lazy unfolding is omitted here, and we refer the reader to the above literatures.
4.2. Core Satisfiability Optimisations
In the following, we present core reasoning of , a satisfiability checking algorithm, which implements a highly optimised version on the basis of the tableau algorithm described in Section 3. Before introducing the optimisations extended to the naive tableau algorithm, we present a brief introduction to backjumping and global caching and show how such algorithms are implemented in practice.
4.2.1. Dependency Directed Backtracking (Backjumping)
Backjumping is an optimisation that is crucial for effective tableau based reasoning. Inherent unsatisfiability concealed in subformulae can lead to large amounts of unproductive backtracking search known as thrashing, especially if the unsatisfiability caused by the modal subformulae had been slightly less trivial [20]. Consider the following modified formula:
To avoid an exponential () search in the case of, a form of dependency directed backtracking called backjumping can be adapted, which has also been used, for example, in solving constraint satisfiability problems [21] and (in a slightly different form) in the HARP theorem prover [22]. The arithmetic labels each formulain a nodewith a dependency setindicating the branching points on which it depends.
In case node is with , and are used to identify the most recent branching point on which or depends. If the dependance exists, the algorithm can then jump back toover intervening branching points without exploring any alternative branches (nondeterministic choices) and make a different nondeterministic choice which might not lead to the same closure condition being encountered. Figure 1 illustrates how the expansion belowis pruned by backjumping, with the number ofexplored being reduced by. We will go into particulars in Algorithm 2. In case no suchexists, the clash did not depend on any nondeterministic choice, and the algorithm stops, reporting the unsatisfiability of the TBox [20].
4.2.2. Global Caching
In order to avoid the same subproblem being solved again and again, it is possible to cache and reuse the results of such subproblems. The usual technique is to use a hash table to store the satisfiability status of node labels (i.e., sets of concepts treated as a conjunction). At present, there are various caching methods briefly outlined in [23]:(i)no caching DFS (NC),(ii)unsat caching DFS (UC),(iii)mixed caching DFS (MC),(iv)unrestricted global caching and propagation (GCNonDFS),(v)global caching DFS with propagation (GCDFS).
Global caching means that each possible set of concepts/formulas is expanded at most once. With respect to the size of the given problem, the notion of global caching is an ExpTime complexity procedure if the search space contains at most an exponential number of different nodes and as long as the extension of each node requires at most exponential time.
4.2.3. Optimized GLB
From Table 2, we can conclude that an  ABox can contain a number of positive or negative assertions without forming a contradiction. Therefore, it is useful to compute lower and upper bounds of finite lattice degree.
Given a fuzzy KB and an assertion, it is absorbing to compute best lower and upper truthvalue bounds of. To this end we define the greatest lower bound ofwith respect to (denoted byto be. Similarly, we define the least upper bound ofwith respect to (denoted by to be. could be computed from theas = because = = = = = . Determining theand theis called the Best Lattice Degree Bound (BLDB) problem.
Concerning the BCVB problem, we may have a similar algorithm as for fuzzy [9], and an optimization in the search space is to use binary search algorithm reducing in that way the satisfiability checks required. Let and , where and . We employ the binary search algorithm, assuming thatis the middle if we sort the elements of. We evaluate if is satisfied, in case it is we move on to higher degree until , indicating that the previous degree is the.
Let us assume that is a linear order,is ordered by ascending linear order, andis the numbers of lattice degrees. A simple iterative approximation algorithm computing is described in Algorithm 1. The similar algorithm can be easily constructed for the.


The described optimizations in Algorithm 1 for glb are very effective since they reduce the search space of tableau independently ofused. Based on the previous partition based on connectivity optimization, we could select a partitionwhere the individual of assertionis contained. Thus a new set of membership degrees only for it withis evaluated, resulting to greatly less satisfiability checks.
Proposition 14. By using a binary search on, theproblem in with respect to witnessed models can be decided in .
Proof. The complexity of ordering and determiningare and , respectively. Hence, the value ofcan be determined in at most fuzzy entailment tests.
Moreover, the performance of calculatingcan be further improved by preventing recurrent expansion of the expansion rules in . When in which no expansion rule can apply, which is then added to the cached completionforest.
5. The Optimized Algorithm
5.1. Algorithm Overview
Our optimized algorithm builds a completion forest consisting of a collection of trees whose distinguished roots are arbitrarily connected by edges. We firstly explain the structure of in more detail.
Definition 15. A nodein the completion forest extends an and/or node which is a record with extra two attributes:,, where:=, :=
The status of a nonleafnode is computed from the status of itsusing its kind (andnode/ornode) and treating satisfiability with respect to the TBox (i.e., sat) as true and unsatisfiability with respect to the (i.e. unsat) as false. When a node gets status sat or unsat, the status can be propagated to itsin a way appropriate to the forest and/or structure if desired.
An andnode (resp., ornode) becomes unsat (resp., sat) if one of its becomes unsat (resp., sat). For the remaining case, an andnode (resp., ornode) becomes sat (resp., unsat) if the number of its with(resp.,) reduces to.
It is well known that different orders of expanding nondeterministic rules can result in huge (up to several orders of magnitude) differences in reasoning performance [24]. According to empirical analysis in [24], we have the definition as below.
Definition 16. In our terminology, the following ordering would be optimal for extending: the rule has the lowest priority, the generating rules (like therule and therule) have the secondlowest priority, all other rules except forhave the secondhighest priority, and the other rules have the highest priority.
Instead of a topdown approach to most systems used for ordering expansion rules, we use a new ordering heuristic rule by an OrderedRule list to control the application of the expansion rules. The fundamental idea is that expansion rules may become applicable whenever a concept is added to a node label, then the node/concept pair is added to the OrderedRule list.
Definition 17. Granting the demand of Algorithm 2, the tableau expansion rules in Table 3 are divided into three parts: := , := , := .
Additionally, we use a OrderedRule list to control the application of the expansion rules. The OrderedRule list sorts all these entries according to the descending order queued above and gives access to the first element in the list. The strategy for rule applications given above is the standard one, by applying and rules as much as possible and then applying rules to realise existential concepts. Besides, the strategy for choosing which node in the to expand next is in the descending order, and that means that,for example, in will be the first applied rule. The set contains the contents of the resulting. If the applied tableau rule is in, then has one formula in ; if the applied rule is in then has two formulae in ; otherwise, supply one appropriate formula for .
5.2. The Optimized Algorithm Design
In the following, assumeis current expanded node,is a nonnegative integer indicating the thrule application in the run of the tableau algorithm,is a formulain the label of a nodewith a dependency set if a nodecontains both,is finite sets of concepts, and the setcontains the contents of the resulting.
To check whether a given finite set is satisfiable in , where is a Box, the content of the initial nodewith status unexpanded is. Initially, the queue of nodesset covers initially only root nodebut can grow as the algorithm proceeds. Next, we present an Exptime decision procedure for to create a completion forest and/or structure.
We comment on Algorithm 2 given in pseudocode, which determines whether a concept is satisfiable with respect to a TBox , both in NNF. The main whileloop (at line (a)) continues processing nodes until the status ofis determined to be in, or until every node is expanded, whichever happens first.
Inside the main loop, we choose an unexpanded node (at line (b)) and try to apply one and only one of the tableau rules in the order, , to the current node. If the applied tableau rule is within, thenhas one; or, if the applied rule is within, thenhas, ; otherwise, applyandtogiving concept and add this concept to.
After that, for every in(at line (c)), we create the required successor in the only if it does not yet exist. Then, the procedure attempts to compute the status of such a nonleafnodeemploying the kind (ornode/andnode) ofand the status of theof, regarding as irrevocably false and as irrevocably true.
On the condition that previous two steps cannot determine the status ofas or , then its status is set to be expanded. On the other side, if so (at line (d)), this information is itself propagated toofin the via the routine .
Sequentially, if and in (at line (e)),, then the closure dependency set, and the algorithm backtracks to theth branching point to apply thrule application. would be restored to its state prior to addingto, and the rule would be applied again such thatwas added to.
Using backjumping, the algorithm will return without expanding the completion trees obtained by adding the varioustoimmediately (at line (f)) because. Satisfiable will eventually return, concluding thatis unsatisfiable.
If(at line (g)), the result is false, otherwise true.
Proposition 18. Let be constructed by Algorithm 2 for and, withas the initial node. Then is satisfiable with respect toif and only if.status = sat.
Lemma 19. Algorithm 2 assumes that is consistent and constructs a model ofthat satisfies . Let be the completion forest constructed by the algorithm for . Suppose the set of concepts carried by the nodeis, for every, if.status = unsat, thenis inconsistent with respect to.
Proof (sketch).. Sinceonly depends on its successors and by copying nodes to ensure that the resulting structure is a completiontree tableau, we can construct a closed tableau with respect tofor the set of concepts carried by the nodeby induction.
5.3. Computational Complexity of the Optimized Algorithm
We proceed to analyse the runtime of the global caching algorithm, under suitable sanity assumptions on the set of modal rules. Specifically, in order to ensure that executions of the algorithm run in exponential time, we need to assumeis the size of input, that is, the sum of the size of . This construction uses both caching and backjumping techniques.
Proposition 20. Algorithm 2 runs in ExpTime.
Proof (sketch).. Since, so the set containsconcepts. Omitting the execution time of procedure propagate, everyis expanded only once and every expansion takestime units.
Whenbecomes sat or unsat, the propagate procedure executesbasic steps directly involved with, so the total time of the executions of propagate is of rank.
Using backjumping, the algorithm returns fromth branching point immediately because. This is obviously true for all of the preceding branching points, so all calls toth branching point will return without expanding the completion trees to. So that the size of can be further reduced.
6. Evaluation
In this section, we provide test results about the usefulness of the optimizations of our algorithm on the test from revised LogicsWork Bench (LWB) benchmarks [25] and the DL98 benchmarks (http://dL.kr.org/dl98/comparison/). All the experiments were conducted under Ubuntu 12.04 on a PC with 2.40 GHz Intel Core 2 CPU Q8300 and 2 GB RAM, using the 1s time limit for each test problem. We consider only the number of solved problems instead of the used CPU time.
6.1. Programming Language
The problem we are dealing with in this work is whether the optimized tableau algorithm proposed by us can be implemented to give an efficient prover for. This problem can be raised as what optimization techniques can be implemented to obtain a prover for that is both optimal from the theoretical point of view and efficient in practice. To the best of our knowledge, there is no DL/uncertainty prover/reasoner for. Thus we have developed in C++ a tableau prover for, which uses serial of optimization methods described above.
C++ is chosen to implement tableau prover because of its increase efficiency, portability, and extendibility. Pointers are intensively used for the data structures of the tableau prover to reduce memory use and to allow caching objects like formulas, sets of formulas, and nodes of a completion forest. Advanced data structures of C++ with low complexity like the templates set, map, multimap, and priority queue are also intensively used. And it is more convenient to extending it for other description logics in a modular way [26].
6.2. Experimental Results on Usefulness of the Optimizations
Because neither do good benchmarks for seem to exist, so we found it hard to compile a good set of test problems. Although the Tableaux’98 and random test suites could show how optimisations perform on propositional modal logics, neither is very good for our purposes.
We therefore recast the K, KT, and S4 problem sets from the LogicsWork Bench (LWB) benchmarks and the T98sat problem set from the DL98 benchmarks (there are 4 sets of DL98 test suite, and only concept satisfiability tests are employed) to be compatible with the fuzzy logic over finite lattices. Due to the space limit, we omit the detailed process of transformation. The three anterior benchmarks measure the performance of the system when testing the satisfiability of large concept expressions without reference to a Tbox. Moreover, DL98 TBox problem set textttT98sat test is added to contain TBox axioms. The correctness of the system is also tested by checking that the answer is as expected.
Our algorithm is fairly detailed, so a naive implementation should be straightforward. The preprocessing optimisations (“partition based on connectivity" and “dealting with TBox axioms”) described in Section 4.1 take at most polynomial time to run and reduce the search space more significantly than the extended framework of Donini and Massacci [27]. So it is sensible to use them in almost every case in our tableau prover. After preprocessing, it is crucial to employ core satisfiability optimisations presented in Section 4.2 that try to improve the performance of the core satisfiability tester.
We intend to show which of the optimisations are most effective, so we have had compiletime configuration options included that can be used to turn on and off or vary the previous optimisations. We chose to test various combinations with all the other optimisations enabled and then to test the same optimisations options, with each of the optimisations turned off one by one. The optimisations that were removed are as follows.(i)ALL: turn on all the optimizations.(ii)No partition based on connectivity (NP): turn off ABox partition.(iii)No dealing with TBox axioms (ND): turn off dealing with TBox axioms.(iv)No backjumping (NB): turn off backjumping.(v)No global caching (NC): turn off global caching.
We end up with 5 configurations and ran each of these configurations over the nine test suites from satisfiability checking problems. For the corresponding subset of tests and the corresponding set of options, each table cell includes the number of solved problems, where the diamond symbol denotes 21 (the number of test problems in the subset). For each configuration, there are five entries corresponding to timeouts of 1 second, 2 seconds, 4 seconds, 8 seconds, and 16 seconds.
6.2.1. K() Tests
Table 4 obviously reveals that, amongst the tested configurations, turning on all the optimizations provides the most effective method. These two other optimisations are the most effective, whose absence in the experiments has made them unacceptably slow. For k_lin_n() and k_lin_p(), the methods of global caching significantly outperform backjumping. There is a nice distinction between the two preprocessing optimisations methods. Partition based on connectivity and dealing with TBox axioms is less important at least within our set of test cases. For k_lin_n(), k_path_n(), and k_path_p(), “dealing with TBox axioms" significantly outperforms “partition based on connectivity," and for the other problems, “partition based on connectivity" outperforms “dealing with TBox axioms."
6.2.2. KT() Tests
Similar testing was performed on KT() tests, and results are showed in Table 5. Again, there is too much data to present it that global caching significantly outperforms other optimization methods in both of its incarnations. Particularly, we have undergone an increase of memory usage by a worstcase factor of two in case of backjumping in comparison to no backjumping. This time, for the most problems, the “partition based on connectivity” method is on par with “dealing with TBox axioms.”
6.2.3. S4() Tests
The results of S4() tests, given in Table 6, show that backjumping performs very well compared to other methods. This result is surprising; global caching is less effective at almost all in this test suite. The probable reason for the ineffectiveness of the method is that, with such a small number of literals in the successor nodes, the purely propositional problems can always be worked out deterministically, while the performance is contingent on the efficiency of propositional reasoning at the root node.
There appears to be no clear winner between the two methods “partition based on connectivity” and “dealing with TBox axioms.” “Dealing with TBox axioms" method outperforms the “partition based on connectivity” method for most problems, and for the problems s4_ipc_p() and s4_path_p(), “dealing with TBox axioms” method beats the “partition based on connectivity" method. However, the differences are not great.
6.2.4. K() TBox Tests
Due to latticed LWB benchmarks not covering TBox problem, so test on the test set DL’98 T98 kb is employed. As shown in Table 7, in this test, “dealing with TBox axioms" is by far the most important optimisation. The next most important optimisations are global caching and backjumping. That is because of explosion in the large size of the search space () in the problems, which results in a destructive degradation in performance, even when optimisations such as global caching and backjumping are used. “Partition based on connectivity" method is almost totally ineffective.
The results reveal that, amongst the tested configurations, global caching is more efficient over the other methods in most but not all cases. Since global caching severely prunes the search space by avoiding multiple expansions of the same node, by enabling greater propagation of sat and unsat via subset checking and hence allowing more cutoffs to be done [28]. Backjumping approach can be applied together with global caching well, which reduces the number of tested nondeterministic branches largely especially for S4() Tests, while in particular, the method may increase memory usage. When considering TBox problem, “dealing with TBox axioms” is the most important optimisation. Sometimes “partition based on connectivity" method is very effective but not all the time.
As shown in the test results, the difference between using preprocessing optimizations or not is less significant than the core satisfiability optimization at least within our set of test cases. Furthermore, preprocessing optimizations cooperates very well with core satisfiability optimization techniques in most of the time.
7. Conclusion and Future Work
Many papers offer technical contributions but without practical motivations. Our method for is definitely promising and should be extended to more expressive logics to test whether it remains feasible. In the further way, the tableau algorithm can be used on the large scale data set such as linked data to solve the practical problem. As far as we know  is the first presentation of a reasoning algorithm for such complex fuzzy DL languages over finite residuated lattices. Besides, this is the first time that optimized techniques were used to tableau reasoning for completion forest in DLs augmented by De Morgan lattices. This enabled us to treat the case of general concept inclusions instead of the simpler acyclic TBoxes.
Of course, there remains plenty of work to do with the tableau algorithm of, such as to directly and efficiently handle general TBoxes and to deal with concrete domains. We intend to extend also for more description logics under more semantics. Besides, the presented dependency management allows for more informed backjumping, while also supporting the creation of precise cache unsatisfiability entries [29]. Among others, better heuristics are needed to guide the choices needed during tableau reasoning, and better use of cached information is expected to provide significant benefits. Additionally, like other related research areas such as Semantic Web, most DL reasoners are implemented in Java for usability by many applications, so the Java implementation of the optimized algorithm will be carried out in the future work.
Conflict of Interests
The authors declare that there is no conflict of interests regarding the publication of this paper.