# Answering Fuzzy Conjunctive Queries over Finitely Valued Fuzzy Ontologies

Fuzzy Description Logics (DLs) provide a means for representing vague knowledge about an application domain. In this paper, we study fuzzy extensions of conjunctive queries (CQs) over the DL SROIQ based on finite chains of degrees of truth. To answer such queries, we extend a well-known technique that reduces the fuzzy ontology to a classical one, and use classical DL reasoners as a black box. We improve the complexity of previous reduction techniques for finitely valued fuzzy DLs, which allows us to prove tight complexity results for answering certain kinds of fuzzy CQs. We conclude with an experimental evaluation of a prototype implementation, showing the feasibility of our approach.

## Authors

• 8 publications
• 2 publications
• 16 publications
• 2 publications
• ### Computing Datalog Rewritings beyond Horn Ontologies

Rewriting-based approaches for answering queries over an OWL 2 DL ontolo...
04/04/2013 ∙ by Bernardo Cuenca Grau, et al. ∙ 0

• ### Temporal Conjunctive Query Answering in the Extended DL-Lite Family

03/20/2020 ∙ by Stefan Borgwardt, et al. ∙ 0

• ### Reasoning with Very Expressive Fuzzy Description Logics

It is widely recognized today that the management of imprecision and vag...
10/31/2011 ∙ by I. Horrocks, et al. ∙ 0

• ### Computing Crisp Bisimulations for Fuzzy Structures

Fuzzy structures such as fuzzy automata, fuzzy transition systems, weigh...
10/27/2020 ∙ by Linh Anh Nguyen, et al. ∙ 0

• ### Answering Counting Queries over DL-Lite Ontologies

Ontology-mediated query answering (OMQA) is a promising approach to data...
09/02/2020 ∙ by Meghyn Bienvenu, et al. ∙ 0

• ### Characteristic Logics for Behavioural Metrics via Fuzzy Lax Extensions

Behavioural distances provide a fine-grained measure of equivalence in s...
07/02/2020 ∙ by Paul Wild, et al. ∙ 0

• ### The State of the Art in Developing Fuzzy Ontologies: A Survey

Conceptual formalism supported by typical ontologies may not be sufficie...
05/06/2018 ∙ by Zahra Riahi Samani, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Description Logics (DLs) are a family of knowledge representation languages with unambiguous syntax and well-defined semantics that are widely used to represent the conceptual knowledge of an application domain in a structured and formally well-understood manner. DLs have been successfully employed to formulate ontologies for a range of knowledge domains, in particular for the bio-medical sciences. Prominent examples of ontologies in these areas are the Gene Ontology, and the ontology Snomed CT. 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 .

In DLs, knowledge is represented through concepts that describe collections of objects (that is, correspond to unary predicates from first-order 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

 (CPU⊓Overused)(cpuA) (1) Server⊓∃hasPart.Overused ⊑ServerWithLimitedResources (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 first-order logic. Adopting this view, one can use a triangular norm (t-norm) and its associated operators to interpret the different logical constructors. Each t-norm 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 BaBP-JPL14 ; BoDP-AI15 . 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 t-norm based finitely valued semantics BoPe-JoDS13 ; borgwardt2013consistency . Unfortunately, the automata-based techniques exploited in BoPe-JoDS13 cannot be easily adapted to obtain complexity bounds for the problem of answering conjunctive queries in these logics. Moreover, despite providing optimal complexity bounds, automata-based methods are not used in practice due to their bad best-case 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 BoDG-IJUF09 ; 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 BoDG-IJUF09 ; bobillo2013finite is that it may introduce an exponential blow-up 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:

 {Server(x)⩾1, hasPart(x,y)⩾1, CPU(y)⩾1,Overused(y)⩾0.6}.

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 black-box 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 blow-up of the ontology, if done according to BoDG-IJUF09 ; bobillo2013finite . We strengthen our results by providing a linear preprocessing step that avoids the exponential blow-up 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 BDGS-IJUF12 ; bobillo2011reasoning ; MaPe-RR-14 are incorrect for qualified number restrictions (indicated by the letter in the name of DLs) by means of a counter-example (see Example 4).

• We discuss a possible way to reduce such qualified number restrictions, but which depends on the presence of so-called Boolean role constructors RuKH-JELIA08 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 reduction-based DeLorean reasonerBoDG-ESA12 for fuzzy ontologies and a standard query answering reasoner for crisp ontologies (PAGOdA ZCGNH-DL-15 ).

A preliminary version of this paper can be found in MaPe-RR-14 , 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 MaPe-RR-14 in order to eliminate an exponential blow-up 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 t-norms, 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

 (x⊗y)⩽z iff y⩽(x⇒z) for all x,y,z∈C.

The residual negation  is defined simply as . Finally, the t-conorm, used for the disjunction, is defined as for all . Two prominent families of operators are based on the finite Gödel t-norm and the finite Łukasiewicz t-norm (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 t-norm.

An alternative to t-norm based approaches for interpreting the logical connectives in fuzzy logics is the so-called 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 C-SROIQ

We introduce finitely valued, fuzzy extensions of the classical description logic  horrocks2006even —one of the most expressive decidable DLs which provides the direct model-theoretic 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),

•   (at-least restriction),

•   (at-most 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 non-empty 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.

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 two-valued 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.

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  BoDG-IJUF09 ; BDGS-IJUF12 . 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

 { Server(serverA),CPU(cpuA),Memory(memA), ⟨Overused(cpuA)⩾0.8⟩,Overused(memA), hasPart(serverA,cpuA),hasPart(serverA,memA), ⟨ServerWithAvailableResources(serverB)⩾0.6⟩, ⟨isConnectedTo(serverA,serverB)⩾0.8⟩},

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

 ⟨Server⊓ ∃hasPart.(Overused⊓CPU)⊓ ∃hasPart.(Overused⊓Memory) ⊑ServerWithLimitedResources⩾0.8⟩,

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

 (x1,…,xk)←α1,…,αm,

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 blow-up. It is well-known that query entailment and query answering can be mutually reduced and that decidability and complexity results carry over modulo the mentioned blow-up calvanese1998decidability .

###### Example 2

Consider the UCQ , consisting of the following CQs:

 (y,x) ←monitors(x,y), (x,x) ←SelfMonitored(x).

To obtain all answers of this UCQ, we consider all possible tuples and instantiate the CQs as follows:

 () ←monitors(b,a), () ←SelfMonitored(a), a≈b,

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 .444In 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

 {Server(x)⩾1,hasPart(x,y)⩾1,CPU(y)⩾1,Overused(y)⩾0.6}

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

 (x1,…,xk)←α1⩾d1,…,αm⩾dm,

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,

 {Server(x),hasPart(x,y),CPU(y),Overused(y)} (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

 (x1,…,xk)←α1,…,αm,

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:

 qt :={hasPart(x,y)⩾1,Overused(y)⩾0.9}, qf :={hasPart(x,y),Overused(y)},

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 GIKK-RR13 ; Rosa-ICDT07 . 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 t-norms (see BDGS-IJUF12 ; bobillo2011reasoning ; MaPe-RR-14 ) is that this reduction introduces an exponential blow-up 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 BDGS-IJUF12 ; bobillo2011reasoning ; MaPe-RR-14 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 BDGS-IJUF12 ; bobillo2011reasoning ; MaPe-RR-14 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:

 \Amc:={ r(a,a),r(a,b),r(b,a),r(b,c),r(c,b),r(c,c), a≠b,b≠c,a≠c}, \Tmc:={ ⊤⊑≤2r.⊤,⊤⊑≥2r.⊤}.

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

 \Tmc′:={ ⊤⊑≤2r.⊤,⊤⊑∃r.B1⊓∃r.B2, B1⊓B2⊑⊥,⊤⊑B1⊔B2}.

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 ; BDGS-IJUF12 .

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 at-most restrictions can be expressed using negation and at-least restrictions; that is, has the same semantics as (cf. Table 2). Hence, in the following we focus on methods for handling at-least number restrictions. Furthermore, we can assume without loss of generality that they only occur in axioms of the forms

 ⟨A⊑≥mr.B⩾d⟩and⟨≥mr.B⊑A⩾d⟩,

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:

 ⟨A⊑∃ri.C⩾d⟩,ri⊑r,dis(rj,rk),

for all with . This is correct due to the minimum used in the semantics of at-least 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 at-least restrictions that occur on the right-hand side of GCIs (and all at-most restrictions that occur on the left-hand side of GCIs).

Unfortunately, this approach does not work for at-least restrictions occurring on the left-hand 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

 r⊑r1⊔⋯⊔rm, (4)

which involves a role disjunction that is interpreted using the maximum, i.e.,

 (r1⊔⋯⊔rm)\Imc(x,y):=mmaxi=1r\Imci(x,y).

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 RuKH-JELIA08 . Moreover, some query answering procedures for classical DLs even work in the presence of such constructors CaEO-IJCAI09 . 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

 ⟨∃r1.C⊓⋯⊓∃rm.C⊑A⩾d⟩.

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 BDGS-IJUF12 ; bobillo2011reasoning ; MaPe-RR-14 , this incurs an exponential blow-up 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) RuKH-JELIA08 ; the reduction of the role constructors is similar to the one for concepts.

### 3.2 Ontology normalization for C-SROIN ontologies

The reason that the reductions described in bobillo2009fuzzy ; BDGS-IJUF12 ; bobillo2011reasoning can cause an exponential blow-up 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 left-hand side. Because of this, the subsequent reduction of a - ontology to a classical ontology  causes only a linear blow-up in the size of (and a quadratic blow-up 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, BoDG-IJUF09 provides a different reduction for this case that does not exhibit an exponential blow-up even without normalization. Hence, we consider in the following result only semantics that are based on finitely valued t-norms 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 t-norm based semantics, every model of can be extended to a model of  by interpreting the new concept names  like  and like .555Where (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 blow-up 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:

 { Overused⊓CPU⊑A, Overused⊓Memory⊑B, ∃hasPart.A⊑C, ∃hasPart.B⊑D, Server⊓C⊑E, ⟨E⊓D⊑ServerWithLimitedResources⩾0.8⟩}

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 BDGS-IJUF12 (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 short-hand 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 :

 A>d⊑A⩾d, r>d⊑r⩾d.
• 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 ; BDGS-IJUF12 ; 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 blow-up of the crispification approach. In particular, we greatly improve the exponential bounds shown in BDGS-IJUF12 ; 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).