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 completion-forest with a series of sound optimization technique for checking satisfiability with respect to a TBox in the logic, a new optimized ExpTime (complexity-optimal) 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 of as 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 t-norm 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 - , where is a complete De Morgan lattice equipped with a t-norm 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 tableaux-based 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). Let and be 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, where and is a complex role:

A complex role is transitive if either or inverse of belongs to .

Definition 2 (semantics). For a residuated De Morgan lattice , an interpretation is now a pair , where is the domain for the classical case and is an interpretation function mapping: every concept name a function and every role name a function . An -assertion is an expression , a role assertion of the form , where is 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 base consists 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). Let be - concept descriptions, a TBox, and . is -satisfiable with respect to if there is a model of such that . The best satisfiability degree for with 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 KB is -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]. Since is 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, then - has the n-witnessed 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 well-known tableau algorithm for - [10], which is the basis for several highly successful implementations.

It is assumed that is finite, and we can accordingly restrict reasoning to -witnessed models. In the lattice , we employ the symbols and as a placeholder for the inequalities and and the symbol as a placeholder for all types of inequations. Furthermore we employ the symbols and to denote their reflections.

Definition 6. For a fuzzy concept , we will denote by the set that contains and it is closed under subconcepts of . The set of all subconcepts of concepts that appear within an ABox is denoted by sub( ). Let be the set of roles occurring in and together with their inverses, and is the set of individuals in . A fuzzy tableau for is 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 of and pair of elements to the degree of certainty of the pair to the role,(iv) : maps individuals occurring in to elements in .
For all , , , and , satisfies the following. (1) , for .(2)If , then .(3)If , then and .(4)If , then and .(5)If , then and .(6)If , then and .(7)If and is conjugated with , then .(8)If and is conjugated with , then .(9)If , then there exists such that and , then .(10)If , then there exists such that and , then .(11)If , and is conjugated with , for some with   Trans( ), then .(12)If , and is conjugated with , for some with   Trans( ), then .(13) if .(14)If and then, .(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. An - ABox 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 , where is a binary fuzzy relation defined as for all , and represents its sup-min 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 for is a collection of trees whose distinguished roots are arbitrarily connected by edges. Each node is labelled with a set . Each edge is labelled with a set , where are roles and its inverse occurring in . A completion forest comes with an explicit inequality relation on nodes and an explicit equality relation which are implicitly assumed to be symmetric. Given a completion forest, If nodes and are connected by an edge with occurring in , then is called an - of and is called an - of . A node is 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 its -predecessor is either directly or indirectly blocked. A node is directly blocked if and only if none of its ancestors are blocked, and it has an ancestor such 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 of -constraints is a conjugated pair (e.g. and is a conjugated pair as ).

The calculus is based on a set of constraint propagation rules transforming a set into satisfiability preserving sets until either one of contains an inconsistency (clash), or some is completed and clash-free; that is, no rule can further be applied to and contains no clash (indicating that from a model of can be built).

is then expanded by repeatedly applying the rules from Table 3. The notation denotes either the role or 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 to such that they yield a complete completion-forest such that has a solution, then has a model;(iii)if has a model, then the expansion rules can be applied in such a way that the tableaux algorithm yields a complete completion forest for such that has 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 the -witnessed model property for some , the completion forest has to generate different 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 than and 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 t-norms 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 2-NExptime, 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 tableau-based 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 tableau-based 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 that may 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 assertions and are in the same if is directly or indirectly inferred from (through the application of completion rules), or and differ 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 denote with the partition of the ABox that contains only connected individuals in

Proposition 13. It holds that(1) ,(2) , for each pair such 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 of leads to the construction of a completion forest containing nodes, then there are different ways to apply the - and -rules to the resulting copies 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 formula in a node with a dependency set indicating 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 to over 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 below is pruned by backjumping, with the number of - explored being reduced by . We will go into particulars in Algorithm 2. In case no such exists, 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 (GC-NonDFS),(v)global caching DFS with propagation (GC-DFS).

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 truth-value bounds of . To this end we define the greatest lower bound of with respect to (denoted by to be . Similarly, we define the least upper bound of with respect to (denoted by to be . could be computed from the as = because = = = = = . Determining the and the is 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 that is 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, and is 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 .

Data: Let , , , .
Result:   .
  while     do
   if     then

Input: A TBox in NNF and a finite set of concepts in NNF
Output: an and-or forest , with as the initial node such that sat, unsat}
  create a new node with and = unexpanded;
  let , ;
(a)   while   {sat, unsat}  do
(b)    choose an node ,   := unexpanded;
     if no - -tableau rule is applicable to   then
     else if   is applicable to   then
     else if      is applicable to giving concept   then
         := and-node, ;
     else if      is applicable to giving concepts and   then
         := or-node, ;
        (i) := and-node;
        (ii) for every , apply    to giving concept and add this
        concept to ;
(c)    for     do
        (i) if      has   then
        then add edge ( ) to ;
        (ii) let be a new node, set , := unexpanded, add to , and add edge ( ) to ;
(d)    if ( .kind = or-node and one of the successors of has status sat) or ( .kind = and-node and all the
     successors of have status sat) then
         := sat, propagate( );
     else if ( .kind = and-node and one of the successors of has status unsat) or ( .kind = or-node and all the
     successors of have status unsat) then
         unsat, propagate( );
         := expanded;
(e)    if   = unsat  and   in ,   then
     else if   := unexpanded  then
        if   is of the form   then
        save( );
        add to with ;
(f)       if     then
         add to with ;
(g)   If   = unsat  then
     return false;
     return true;

The described optimizations in Algorithm 1 for glb are very effective since they reduce the search space of tableau independently of used. Based on the previous partition based on connectivity optimization, we could select a partition where the individual of assertion is contained. Thus a new set of membership degrees only for it with is evaluated, resulting to greatly less satisfiability checks.

Proposition 14. By using a binary search on , the problem in - with respect to witnessed models can be decided in .

Proof. The complexity of ordering and determining are and , respectively. Hence, the value of can be determined in at most fuzzy entailment tests.
Moreover, the performance of calculating can 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 completion-forest.

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 node in the completion forest extends an and/or node which is a record with extra two attributes: , , where := , :=

The status of a non-leaf-node is computed from the status of its - using its kind (and-node/or-node) 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 its - in a way appropriate to the forest and/or structure if desired.

An   and-node (resp., or-node) becomes   unsat (resp., sat) if one of its - becomes   unsat (resp., sat). For the remaining case, an   and-node (resp.,   or-node) 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 the -rule and the -rule) have the second-lowest priority, all other rules except for have the second-highest priority, and the other rules have the highest priority.

Instead of a top-down 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, assume is current expanded node, is a nonnegative integer indicating the th- rule application in the run of the tableau algorithm, is a formula in the label of a node with a dependency set if a node contains both , is finite sets of concepts, and the set contains the contents of the resulting .

To check whether a given finite set is satisfiable in , where is a Box, the content of the initial node with status unexpanded is . Initially, the queue of nodes set covers initially only root node but 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 while-loop (at line (a)) continues processing nodes until the status of is 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 , then has one ; or, if the applied rule is within , then has , ; otherwise, apply and to giving 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 non-leaf-node employing the kind (or-node/and-node) of and the status of the - of , regarding as irrevocably false and as irrevocably true.

On the condition that previous two steps cannot determine the status of as or , then its status is set to be expanded. On the other side, if so (at line (d)), this information is itself propagated to - of in the via the routine .

Sequentially, if and in (at line (e)), , then the closure dependency set , and the algorithm backtracks to the th branching point to apply th- -rule application. would be restored to its state prior to adding to , and the rule would be applied again such that was added to .

Using backjumping, the algorithm will return without expanding the completion trees obtained by adding the various to immediately (at line (f)) because . Satisfiable will eventually return , concluding that is unsatisfiable.

If (at line (g)), the result is false, otherwise true.

Proposition 18. Let be constructed by Algorithm 2 for and , with as the initial node. Then is satisfiable with respect to if and only if .status =   sat.

Lemma 19. Algorithm 2 assumes that is consistent and constructs a model of that satisfies . Let be the completion forest constructed by the algorithm for . Suppose the set of concepts carried by the node is , for every , if .status =   unsat, then is inconsistent with respect to .

Proof (sketch).. Since only depends on its successors and by copying nodes to ensure that the resulting structure is a completion-tree tableau, we can construct a closed tableau with respect to for the set of concepts carried by the node by 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 assume is 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 contains concepts. Omitting the execution time of procedure propagate, every is expanded only once and every expansion takes time units.
When becomes   sat or   unsat, the propagate procedure executes basic steps directly involved with , so the total time of the executions of propagate is of rank .
Using backjumping, the algorithm returns from th branching point immediately because . This is obviously true for all of the preceding branching points, so all calls to -th 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   T98-sat 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 textttT98-sat 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 compile-time 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 worst-case 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.