1 Introduction
Description Logics (DLs) are a family of knowledge representation languages with unambiguous syntax and welldefined semantics that are widely used to represent the conceptual knowledge of an application domain in a structured and formally wellunderstood manner. DLs have been successfully employed to formulate ontologies for a range of knowledge domains, in particular for the biomedical sciences. Prominent examples of ontologies in these areas are the Gene Ontology,^{1}^{1}1http://geneontology.org/ and the ontology Snomed CT.^{2}^{2}2http://ihtsdo.org/snomedct/ Arguably the largest success of DLs to date is that they provide the formal foundation for the standard web ontology language OWL, a milestone for the Semantic Web. More precisely, the current version of the web ontology language, OWL 2, is based on the very expressive DL .^{3}^{3}3http://www.w3.org/TR/owl2overview/
In DLs, knowledge is represented through concepts that describe collections of objects (that is, correspond to unary predicates from firstorder logic), and roles that define relations between pairs of objects (binary predicates). To encode the actual knowledge of the domain, DLs employ different kinds of axioms. These axioms restrict the possible interpretations of the concepts and roles. For example, we can express the fact that is an overused CPU, and that every server that has a part that is overused is a server with limited resources through the axioms
(1)  
(2) 
An axiom of the form (1) is called an assertion, while (2) is a general concept inclusion (GCI).
It has been widely argued that many application domains require the representation of vague concepts, for which it is impossible to precisely characterize the objects that belong to these concepts, and distinguish them from those who do not belong to them straccia2013foundations . A simple example of such a concept is that of an overused CPU. While it is easy to state that a CPU that is running permanently at its maximum capacity is overused, and one that is not being used at all is not overused, there is no precise usage point where a CPU starts (or stops) being overused. Fuzzy Description Logics have been proposed to alleviate this problem. In these logics, objects are assigned a membership degree, typically a number between 0 and 1, expressing “how much” they belong to a given concept. In general, the higher the degree of an object, the more it belongs to the concept. To represent vague knowledge, axioms are also extended to restrict the possible degrees that the interpretations may use. Thus, one can express that is overused with degree at least 0.8 through the assertion .
Formally, fuzzy DLs generalize classical DLs by interpreting concepts and roles as fuzzy unary predicates and fuzzy binary predicates, respectively. Hence, fuzzy DLs can be seen as sublogics of fuzzy firstorder logic. Adopting this view, one can use a triangular norm (tnorm) and its associated operators to interpret the different logical constructors. Each tnorm then defines a specific family of fuzzy DLs.
It has been shown that reasoning in fuzzy DLs easily becomes undecidable, if infinitely many membership degrees are allowed BaBPJPL14 ; BoDPAI15 . In fact, these undecidability results hold even for relatively inexpressive fuzzy DLs. This has motivated the study of finitely valued fuzzy DLs.
It is known that the complexity of standard reasoning tasks in expressive DLs is not affected by the use of tnorm based finitely valued semantics BoPeJoDS13 ; borgwardt2013consistency . Unfortunately, the automatabased techniques exploited in BoPeJoDS13 cannot be easily adapted to obtain complexity bounds for the problem of answering conjunctive queries in these logics. Moreover, despite providing optimal complexity bounds, automatabased methods are not used in practice due to their bad bestcase behavior.
A different approach for reasoning in the presence of finitely many membership degrees is crispifying; i.e., transforming a finitely valued ontology into an “equivalent” classical ontology, from which the relevant membership degrees can be read BoDGIJUF09 ; bobillo2013finite ; straccia2004transforming . Reasoning in finitely valued fuzzy DLs is thus reduced to reasoning in classical DLs, for which very efficient methods have already been developed and implemented. The main drawback of the translation described in BoDGIJUF09 ; bobillo2013finite is that it may introduce an exponential blowup of the ontology, thus affecting the efficiency of the overall method.
In this paper, we adapt the crispification approach for answering conjunctive queries in expressive finitely valued fuzzy DLs. The problem of answering conjunctive queries has recently received much attention as a powerful means to access facts encoded in an ontology. For example, using a fuzzy conjunctive query it is possible to ask for all pairs of servers and CPUs such that the CPU is an overused part (to degree at least ) of the server as follows:
The crispification approach allows us to effectively answer conjunctive queries over finitely valued ontologies, by reusing the methods developed for the classical case. Once the ontology is crispified, this approach calls a classical conjunctive query answering engine as a blackbox procedure. Thus any optimization developed for the classical case automatically improves the performance for the finitely valued scenario. What remains to be addressed is the exponential blowup of the ontology, if done according to BoDGIJUF09 ; bobillo2013finite . We strengthen our results by providing a linear preprocessing step that avoids the exponential blowup produced by this crispification. Using this preprocessing of the finitely valued ontology, we can guarantee that the classical ontology produced is only polynomially larger than the original input. In particular, this means that the classical query answering engine becomes able to provide answers more efficiently over classical ontologies of lesser size.
The contributions of this paper are the following:

We prove that some of the previous crispification algorithms BDGSIJUF12 ; bobillo2011reasoning ; MaPeRR14 are incorrect for qualified number restrictions (indicated by the letter in the name of DLs) by means of a counterexample (see Example 4).

We discuss a possible way to reduce such qualified number restrictions, but which depends on the presence of socalled Boolean role constructors RuKHJELIA08 in the DL (see Section 3.1).

We improve the reduction from finitely valued ontologies to classical ontologies by introducing a linear normalization step (stands for unqualified number restrictions, see Section 3).

We extend the crispification approach to answering different types of fuzzy conjunctive queries in the finitely valued setting and we prove correctness of the obtained methods (see Section 4). This approach works for any known crispification algorithm, in particular specialized ones that correctly reduce number restrictions.

We assess the complexity of the presented conjunctive query answering technique for a family of fuzzy extensions of (sublogics of) in regard of two types of conjunctive queries that use membership degrees.

We provide an evaluation of a prototype implementation of our methods over the LUBM ontology benchmark guo2005lubm based on the reductionbased DeLorean reasonerBoDGESA12 for fuzzy ontologies and a standard query answering reasoner for crisp ontologies (PAGOdA ZCGNHDL15 ).
A preliminary version of this paper can be found in MaPeRR14 , where the incorrect reduction of number restrictions was still used. We also extend here that earlier paper by full proofs for the correctness of the crispification procedure, something which has not been done before in the literature. Finally, we optimize the crispification procedure described MaPeRR14 in order to eliminate an exponential blowup inherent in some of the previous crispification proposals.
The rest of the paper is structured as follows: Section 2 introduces the syntax and semantics of finitely valued fuzzy DLs based on . Section 3 describes our improved reduction procedure from fuzzy to classical ontologies. Section 4 presents the actual reduction from fuzzy to classical conjunctive query answering. Section 5 provides an evaluation of a prototype implementation over (fuzzified versions of) the LUBM ontology benchmark guo2005lubm . Finally, Section 6 presents the current literature on reduction techniques and conjunctive query answering for fuzzy DLs and Section 7 summarizes the paper and mentions directions for future work.
2 Preliminaries
We first introduce a class of finite chains, together with some basic operations over them. Afterwards, we formally define the fuzzy extension of , whose semantics is based on these chains.
2.1 Finite Fuzzy Logics
The semantics of fuzzy DLs is based on truth structures endowed with additional operators for interpreting the logical constructors. We consider arbitrary finite total orders (or chains). Since the names of the truth degrees in a chain are not relevant, we consider in the following only the canonical chain of elements , in the usual order. We denote by . We use the notation to refer to the direct upper neighbour of in , which is the unique smallest element strictly larger than . We now consider tuples of the form that specify the chain together with the operators used for interpreting conjunction, implication, negation, and disjunction, respectively.
The largest family of operators used for fuzzy semantics is based on tnorms, which are associative, commutative binary operators that are monotonic in both arguments and have identity . These binary operators, denoted by , are used in mathematical fuzzy logic to interpret conjunction. The residuum is a binary operator which is used to interpret implication. It is uniquely defined by the property that
The residual negation is defined simply as . Finally, the tconorm, used for the disjunction, is defined as for all . Two prominent families of operators are based on the finite Gödel tnorm and the finite Łukasiewicz tnorm (see Table 1). Note, however, that we do not restrict our considerations to only those logics listed in Table 1; our results are valid for any semantics based on a finite tnorm.
name  conjunction  disjunction  negation  implication 

Zadeh  
Gödel  
Łukasiewicz 
An alternative to tnorm based approaches for interpreting the logical connectives in fuzzy logics is the socalled Zadeh family of operators, shown in the first row of Table 1. Intuitively, the Zadeh family can be seen as a combination of the Gödel and the Łukasiewicz operators.
2.2 The Fuzzy DL 
We introduce finitely valued, fuzzy extensions of the classical description logic horrocks2006even —one of the most expressive decidable DLs which provides the direct modeltheoretic semantics of the standardized ontology language for the Semantic Web OWL 2. It has been shown that reasoning in finitely valued fuzzy extensions of can be reduced to reasoning in classical bobillo2008optimizing ; bobillo2011reasoning ; straccia2004transforming . This reduction technique will be considered in detail in Section 3.
Consider three countable and pairwise disjoint sets of individual names , concept names , and role names . Individual names refer to single elements of an application domain, concept names describe sets of elements, and role names binary relations between elements. Based on these, complex concepts and roles can be built using different constructors. More precisely, a (complex) role is either of the form or (inverse role), for , or it is the universal role . Similarly, (complex) concepts are built inductively from concept names using the following constructors

(top concept),

(bottom concept),

(conjunction),

(disjunction),

(negation),

(value restriction),

(existential restriction),

(fuzzy nominal),

(atleast restriction),

(atmost restriction), and

(local reflexivity),
where are concepts, is a role, is a natural number, , and .
An ontology consists of the intensional and the extensional knowledge related to an application domain. The intensional knowledge, i.e. the general knowledge about the application domain, is expressed through

a TBox , a set of finitely many (fuzzy) general concept inclusion (GCIs) axioms of the form , where , and

an RBox , a finite set of role axioms, which are statements of the following form:

((fuzzy) complex role inclusion),

(transitivity),

(disjointness),

(reflexivity),

(irreflexivity),

(symmetry), or

(asymmetry),
where are roles and again .

The extensional knowledge, which refers to the particular knowledge about specific facts or situations, is expressed by an ABox containing a finite set of statements about individuals of the form:

(concept assertion),

(role assertion),

(individual inequality assertion), or

(individual equality assertion),
where , is a concept, is a role, , and . If is , then we again consider only values ; dually, for assertions using we assume that .
For any axiom of the form , we may simply write . Finally, an ontology is a tuple consisting of an ABox , a TBox , and an RBox .
To ensure decidability of classical , a set of restrictions regarding the use of roles is imposed. For example, transitive roles are not allowed to occur in number restrictions (for more details see horrocks2006even ). The same restrictions are also adopted for fuzzy extensions of bobillo2008optimizing ; bobillo2009fuzzy ; bobillo2011reasoning . However, they are not essential for our purposes, as all results presented in this paper hold regardless of these restrictions (except, of course, for the complexity results of Section 4.2).
The semantics of  is defined via interpretations. A (fuzzy) interpretation is a pair , consisting of a nonempty set (called the domain) and an interpretation function that maps every individual name to an element , every concept name to a fuzzy set , and every role name to a fuzzy binary relation . This function is extended to complex roles and complex concepts as described in Table 2.
Concept  Semantics for 

Role  Semantics for 
Note that the usual fuzzy semantics of existential and value restrictions, number restrictions, and role inclusions formally requires the computation of an infimum or supremum over all domain elements. However, since is a finite chain, in our case these are actually minima or maxima, respectively.
For the twovalued chain , we obtain the semantics of classical , since then all fuzzy operators correspond their classical counterparts. In this setting, it is more natural to treat as a subset of
, given by its characteristic function
(and analogously for roles). We call such an interpretation a classical interpretation.An ontology is satisfied by a fuzzy interpretation if all of its axioms are satisfied, as defined in Table 3.
ABox  Semantics 

TBox  Semantics (for all ) 
RBox  Semantics (for all ) 
or  
or 
In this case, is called a model of the ontology. An ontology is consistent iff it has a model. In fuzzy extensions of , axioms are often allowed to express also strict inequalities ( and ). However, in the finitely valued setting an axiom with can be expressed as (and similarly for and the direct lower neighbour of ).
In the literature it is also common to find negated role assertions of the form BoDGIJUF09 ; BDGSIJUF12 . However, in our setting is equivalent to an assertion of the form , and similarly for .
Example 1
Suppose that we have a cloud computing environment consisting of multiple servers with their own internal memory and CPU. To model such an environment, we use

the individual names: , , , , , ;

the concept names: , , , , , and
; and 
the role names: and .
The assertional knowledge of this domain is modeled via the ABox
which, for example, states that is overused with degree at least , and that the memory is also overused with degree 1. The terminological knowledge of this domain can be modeled via a TBox containing axioms like
stating that a server with an overused memory and CPU is a server with limited resources. This implication must hold with a degree of at least .
It should be noted that the concepts , , and and the role are essentially crisp; i.e., they can only take values in . This information can be easily modeled as part of a fuzzy ontology and handled by the reduction algorithm in bobillo2008optimizing . In contrast to this, the concepts and have a vague nature; that is, they are fuzzy, and the degree to which a server has limited resources and the degree to which a CPU or a memory card is overused can take values strictly between and . The role is also fuzzy and it is used to declare the connection between two servers. The higher the connection degree between two servers is, the larger bandwidth they use in their communication.
2.3 Conjunctive Queries
Based on the semantics other reasoning services than consistency of ontologies can be defined. In this paper we are interested in conjunctive query answering. We give the definition of classical conjunctive queries next.
Definition 1 (Conjunctive Query)
Let be a countably infinite set of variables disjoint from , , and . An atom is a concept atom of the form , a role atom of the form , or an equality atom of the form , where , , and . A (ary) conjunctive query (CQ) is a statement of the form
where are atoms, and are (not necessarily distinct) variables occurring in these atoms. We call the distinguished variables of . denotes the set of all variables and individual names occurring in . If , we call a Boolean conjunctive query.
Let be a classical interpretation, a Boolean CQ, and a function such that for all . If , then we write , and whenever , and if . If for all atoms in , we write and call a match for and . We say that satisfies and write if there is a match for and .
A (ary) union of conjunctive queries (UCQ) is a set of ary conjunctive queries. An interpretation satisfies a Boolean UCQ , written if for some . For a Boolean (U)CQ and an ontology , we write and say that entails if holds for all models of .
Consider now an arbitrary ary (U)CQ and a tuple of individual names. We say that is an answer to w.r.t. an ontology if entails the Boolean (U)CQ resulting from by replacing all distinguished variables according to (and possibly introducing new equality atoms if some of the distinguished variables in an answer tuple are equal).
The problem of query answering is to compute all answers of a (U)CQ w.r.t. a given ontology. Query answering can be reduced to query entailment by testing all possible tuples , which yields an exponential blowup. It is wellknown that query entailment and query answering can be mutually reduced and that decidability and complexity results carry over modulo the mentioned blowup calvanese1998decidability .
Example 2
Consider the UCQ , consisting of the following CQs:
To obtain all answers of this UCQ, we consider all possible tuples and instantiate the CQs as follows:
which results in a Boolean UCQ. The latter is entailed by an ontology if one can derive that in all models of either the assertion holds, or else both and are satisfied.
If the distinguished variables are clear from the context, we may also omit them and write a CQ simply as a set of atoms.
In fuzzy DLs, conjunctive queries can be of two different types: threshold conjunctive queries or general fuzzy queries pan2007expressive ; straccia2013foundations ; straccia2014top .^{4}^{4}4In straccia2014top , queries are defined that allow for grouping, aggregation, and ranking. Although we do not consider such queries here, we generalize our basic queries in Section 4.3. Threshold queries ask for tuples of individuals that satisfy a set of assertions to at least some given degree. For example, the threshold query
asks for all pairs of servers and CPUs such that the CPU is a part of the server and is also overused to a degree of at least .
Definition 2 (Threshold Conjunctive Query)
A degreeatom is an expression of the form , where is an atom and . A (ary) threshold conjunctive query is of the form
where are degree atoms and are variables. As before, denotes the set of variables and individuals occurring in the threshold CQ .
Let be an interpretation, a Boolean threshold CQ, and a function that maps each to . The degree of an atom w.r.t. is defined as , and we set for ; finally, for we define if , and otherwise. If holds for all degree atoms in , then we write and call a match for and . The notions of satisfaction, entailment, and answers are defined as for classical CQs.
General fuzzy CQs, in contrast, have the same syntax as classical conjunctive queries. Their answers are the tuples of individuals satisfying them to a degree greater than , together with the degree to which the query is satisfied. For example,
(3) 
asks for all overused CPUs that belong to a server, along with the degree to which these CPUs are overused. To obtain the degree of the query from the individual degrees of the atoms, the fuzzy operator interpreting the conjunction is used.
Definition 3 (Fuzzy Conjunctive Query)
A (ary) fuzzy conjunctive query is of the form
where are atoms and are variables. Let be an interpretation, a Boolean fuzzy CQ, and a mapping as in Definition 2. If , then we write and call a match for and with a degree of at least . We say that satisfies with a degree of at least and write if there is such a match. If for all models of an ontology , we write and say that entails with a degree of at least . Finally, a tuple is an answer to a ary fuzzy CQ w.r.t. with a degree of at least if entails with a degree of at least .
The query entailment problem for a (Boolean) threshold CQ is to decide whether . For fuzzy CQs, we may consider two variants of the query entailment problem, namely

to decide whether for a given , or

to find the best entailment degree .
Since we consider only finitely valued semantics over the chain , these two problems can be polynomially reduced to each other. As for classical query answering, it suffices to analyze the complexity of query entailment; the results can then be transferred to query answering calvanese1998decidability .
Example 3
Consider the following queries:
and the ontology from Example 1. An answer to the query is , but not since is only overused to degree . The answers to are the pairs with degree and to degree .
Remark 1
A threshold CQ with inequalities using would correspond to a classical CQ containing negated role atoms, for which query answering is undecidable even in very inexpressive DLs GIKKRR13 ; RosaICDT07 . Similarly, upper bounds for fuzzy conjunctive queries , i.e. asking whether , can be seen as a generalized form of disjunction of (negated) query atoms. For these reasons, we consider only inequalities using .
Before we turn to answering such queries over fuzzy ontologies, we describe the reduction of expressive finitely valued fuzzy ontologies to classical ones.
3 Reduction of Finitely Valued Fuzzy Ontologies to Classical Ontologies
A popular reasoning technique for fuzzy DLs based on finite chains is the reduction of the fuzzy ontology to a classical one. This allows to use existing DL systems to reason in the fuzzy description logic. However, a major drawback of existing approaches for finite chains using arbitrary tnorms (see BDGSIJUF12 ; bobillo2011reasoning ; MaPeRR14 ) is that this reduction introduces an exponential blowup in the size of the fuzzy ontology. While this handicap can be remedied by our normalization step described in Section 3.2 (see also the experiments in Section 5.2), another obstacle needs to be addressed first: the reduction proposed in BDGSIJUF12 ; bobillo2011reasoning ; MaPeRR14 is not correct for number restrictions. In the following, we describe this problem in detail and propose a (partial) solution.
3.1 Treating Number Restrictions
The reduction in BDGSIJUF12 ; bobillo2011reasoning ; MaPeRR14 is based on the idea to simulate number restrictions by existential restrictions in the following way. For a number restriction , the new concept names and the axioms
are introduced, which require them to form a partition. Subsequently, the number restriction is replaced by the concept . The following classical example shows that this replacement does not preserve the semantics of the number restrictions, and thus cannot be correct in the fuzzy case, either.
Example 4
Consider the following ABox and TBox:
A simple model for is given by and . Thus, the ontology is consistent. By replacing according to the method described above, we obtain the TBox
We show that the resulting ontology is inconsistent. Assume to the contrary that there exists a model of the ontology . Without loss of generality, suppose that it interprets the individual names as themselves. Thus, we must have . There are only eight possible combinations for belonging to either or . Suppose first that and . Then by the axiom the individual must have yet another successor . However, this contradicts the GCI . Similar arguments apply for all other combinations, and therefore the ontology is inconsistent.
It should be noted that for Gödel and Zadeh semantics alternative (correct) reductions of number restrictions exist bobillo2009fuzzy ; BDGSIJUF12 .
We now propose an alternative encoding of number restrictions when using other fuzzy semantics, avoiding the problem exhibited by Example 4. Intuitively, instead of using a partition of the target concept of a restriction , we will partition the role . Note first that atmost restrictions can be expressed using negation and atleast restrictions; that is, has the same semantics as (cf. Table 2). Hence, in the following we focus on methods for handling atleast number restrictions. Furthermore, we can assume without loss of generality that they only occur in axioms of the forms
where and are concept names (cf. Section 3.2).
Axioms of the first kind can be equivalently expressed using fresh role names in the following axioms:
for all with . This is correct due to the minimum used in the semantics of atleast restrictions. More precisely, every model of the original axiom can be extended by a suitable interpretation of the new role names to a model of the resulting axioms, and every model of the latter is immediately a model of the former. Hence, we can eliminate all atleast restrictions that occur on the righthand side of GCIs (and all atmost restrictions that occur on the lefthand side of GCIs).
Unfortunately, this approach does not work for atleast restrictions occurring on the lefthand side of GCIs. The reason is that the presence of many successors satisfying does not imply that these successors can be reached using one of the disjoint roles . However, this can be expressed using the additional role axiom
(4) 
which involves a role disjunction that is interpreted using the maximum, i.e.,
Role disjunction is an example of a (safe) Boolean role constructor, which can be added to most classical DLs without increasing the complexity of reasoning RuKHJELIA08 . Moreover, some query answering procedures for classical DLs even work in the presence of such constructors CaEOIJCAI09 . Unfortunately, to the best of our knowledge, role disjunctions are not yet supported by any classical DL reasoner.
In the presence of axiom (4) and the role disjointness axioms from above, the GCI can now be equivalently expressed as
Unlike the incorrect reduction for number restrictions that was first proposed in bobillo2011reasoning , our approach does not partition the range of the role in the number restriction, but rather the role itself, and hence it correctly treats the case where a domain element is an successor of two different elements that are subject to the same number restriction on (recall Example 4). However, like the approach of BDGSIJUF12 ; bobillo2011reasoning ; MaPeRR14 , this incurs an exponential blowup in the largest number occurring in number restrictions, if these numbers are represented in the ontology using a binary encoding. The reduction is polynomial if we assume unary encoding of numbers.
Since role disjunctions are not supported by or OWL 2, we will restrict the following investigation to unqualified number restrictions of the form and , i.e., to the fuzzy logic . However, we want to emphasize that we can easily treat qualified number restrictions in the following reduction if the classical target language supports role disjunctions. It is straightforward to extend the reduction to deal even with , the extension of with full Boolean role expressions (which satisfy a safety condition) RuKHJELIA08 ; the reduction of the role constructors is similar to the one for concepts.
3.2 Ontology normalization for  ontologies
The reason that the reductions described in bobillo2009fuzzy ; BDGSIJUF12 ; bobillo2011reasoning can cause an exponential blowup in the size of the ontology is that concept constructors may be nested to arbitrary depths. In this subsection, we propose a normalization step to ensure that each GCI and concept assertion contains at most one concept constructor, and that each complex role inclusion contains at most two roles on the lefthand side. Because of this, the subsequent reduction of a  ontology to a classical ontology causes only a linear blowup in the size of (and a quadratic blowup in the size of ). For an experimental evaluation of the resulting difference in ontology size and reasoning performance, see Section 5.2.
The normalization proceeds by exhaustively replacing each axiom by a set of axioms according to Table 4.
,  ,  
, ,  , ,  
, ,  , ,  
,  ,  
,  ,  
,  ,  
, 
In that table, denote concept names, , or ; are complex concepts that are neither concept names, , nor ; and , , and are roles. and are fresh concept names that abbreviate the concepts and , respectively. In the last rule, is a fresh role name that stands for the role composition of and . For simplicity, we have given the rules for conjunctions and disjunctions only for the case where both operands are complex concepts. However, if only one of them is a complex concept, we would not introduce a new concept name for the other operand. Note that nominals, unqualified number restrictions, and local reflexivity concepts do not need to be normalized.
It should be noted that this reduction is not correct under Zadeh semantics due to the properties of the implication function. However, BoDGIJUF09 provides a different reduction for this case that does not exhibit an exponential blowup even without normalization. Hence, we consider in the following result only semantics that are based on finitely valued tnorms and their induced operators , , and .
Proposition 1
Let be the ontology resulting from the exhaustive application of the rules in Table 4 to a  ontology . Under tnorm based semantics, every model of can be extended to a model of by interpreting the new concept names like and like .^{5}^{5}5Where (cf. Table 3). Moreover, every model of is already a model of .
This simple observation immediately shows that is consistent iff is consistent. Moreover, it allows us to prove correctness of the normalization procedure also with respect to the other reasoning tasks we will consider in the following sections. Furthermore, it is easy to see that the normalization could be extended to deal also with qualified number restrictions ().
While this procedure involves the introduction of linearly many new concept names, it allows us to circumvent the exponential blowup exhibited by previous reductions.
Remark 2
The reason why this normalization reduces the complexity of the following reduction is that it ensures that each axiom contains at most three occurrences of concept or role names. However, we will see in the following subsection that concept and role names that are interpreted classically, i.e. can take only the values and , do not take part in the reduction. Hence, it is enough to ensure that each axiom contains at most three occurrences of fuzzy concept or role names. Such axioms do not need to be reduced any further. Nevertheless, all complexity results concerning the reduction in the following section remain valid.
Example 5
The normalized form of the TBox containing the GCI from Example 1 is as follows:
However, since the GCI in contains only three occurrences of names of fuzzy concepts (two times and once ), we can use as it is in the following reduction.
We will assume in the following that is already normalized. The remainder of the reduction is very similar to the one described in BDGSIJUF12 (except for number restrictions).
3.3 The Reduction Algorithm
Each concept name and role name in is mapped onto a set of concepts and roles corresponding to their cuts, which are crisp sets containing all elements that belong to a fuzzy set to at least a given degree . For example, if the concept name describes the degree to which a CPU is overused, then represents the set of CPUs that are overused to a degree of at least . It is clear that we do not need to consider the value for such cuts, as always describes the whole domain. We may also refer to concept names of the form for and , which is a shorthand notation for , and similarly for role names.
The ontology obtained from the reduction has the following form:

To preserve the semantics of cuts of concept and role names, the following axioms are added to for all , , and with :

Each complex concept appearing in is mapped to the complex concept that represents its cut regarding degree , as defined in the first part of Table 7 in the appendix.

Each axiom in is then mapped to a classical axiom or set of axioms in according to the mapping defined in the second part of Table 7.
For a more detailed analysis of the reduction rules, the interested reader may refer to bobillo2009fuzzy ; BDGSIJUF12 ; bobillo2011reasoning . We provide a detailed proof of correctness in the appendix.
Theorem 3.1
Let be a  ontology. Then has a fuzzy model iff its reduced form has a classical model.
Our normalization procedure allows us to show the following improved complexity bounds. The proof of the following lemma can be found in Appendix B.
Lemma 1
For a normalized  ontology , the size of is linear in the size of and quadratic in the size of .
This means that, by simply introducing the normalization step, we can avoid the exponential blowup of the crispification approach. In particular, we greatly improve the exponential bounds shown in BDGSIJUF12 ; bobillo2011reasoning .
Example 6
Figure 1 contains the reduced form of the ontology from Example 1 w.r.t. Łukasiewicz semantics over the chain with six elements . We have taken into account that one does not need to consider cuts of classical concept and role names. This nicely illustrates how classical concepts and roles help to reduce the size of the reduction. Not only do we have crisp concept instead of cut concepts, but the number of disjunctions and conjunctions introduced can be reduced dramatically (cf. Table 7).
[t]
Comments
There are no comments yet.