=Paper=
{{Paper
|id=Vol-1350/paper-56
|storemode=property
|title=A
pragmatic approach to answering CQs over fuzzy
DL-Lite-ontologies—introducing FLite
|pdfUrl=https://ceur-ws.org/Vol-1350/paper-56.pdf
|volume=Vol-1350
|dblpUrl=https://dblp.org/rec/conf/dlog/MailisTZ15
}}
==A
pragmatic approach to answering CQs over fuzzy
DL-Lite-ontologies—introducing FLite==
https://ceur-ws.org/Vol-1350/paper-56.pdf
A Pragmatic Approach to Answering CQs over
Fuzzy DL-Lite-ontologies–introducing FLite ?
Theofilos Mailis1 , Anni-Yasmin Turhan2 , and Erik Zenker3
1
Department of Informatics and Telecommunications,
National and Kapodistrian University of Athens, Greece
2
Department of Computer Science, University of Oxford, UK
3
Institute for Theoretical Computer Science,
Technische Universität Dresden, Germany
Abstract. Fuzzy Description Logics (FDLs) generalize crisp ones by
providing membership degree semantics. To offer efficient query answer-
ing for FDLs it is desirable to extend the rewriting-based approach for
DL-Lite to its fuzzy variants. For answering conjunctive queries over
fuzzy DL-Lite R ontologies we present an approach, that employs the
crisp rewriting as a black-box procedure and treats the degrees in a sec-
ond rewriting step. This pragmatic approach yields a sound procedure
for the Gödel based fuzzy semantics, which we have implemented in the
FLite reasoner that employs the Ontop system. A first evaluation of
FLite suggests that one pays only a linear overhead for fuzzy queries.
1 Introduction
Fuzzy variants of Description Logics (DLs) were introduced in order to describe
concepts for which there exists no sharp, unambiguous distinction between mem-
bers and nonmembers. For example, a natural way to model a component run-
ning at half of its capacity is to state that is overused to a degree of, say, 0.6.
In the last years, conjunctive query answering has been investigated for crisp
and fuzzy DLs. The DL-Lite family of DLs [2, 6, 5] guarantees that query an-
swering can be done efficiently —in the size of the data and in the overall size of
the corresponding ontology. Though fuzzy DL-Lite variants have already been
successfully investigated [18, 19, 10], their algorithms do not exploit the opti-
mizations of query rewriting techniques that have been implemented in many
systems for the crisp DLs, such as QuOnto2 [1, 12], Ontop [14], Owlgres [16],
and IQAROS [22].
A pragmatic approach for answering conjunctive queries over crisp DL-Lite R -
TBoxes and fuzzy DL-Lite R -ABoxes, that takes advantage of these optimiza-
tions, was presented in [9]. The combination of crisp TBoxes with fuzzy ABoxes
is useful in applications, where only the data is imprecise, while the terminolog-
ical knowledge is not, e.g., as in situation recognition applications that rely on
sensor data.
?
Partially supported by DFG in the Collaborative Research Center 912 “Highly
Adaptive Energy-Efficient Computing”.
In our pragmatic approach to answering of (fuzzy) conjunctive queries, a
crisp DL-Lite reasoner is used as a black box to obtain an initial rewriting of the
conjunctive query (without the fuzzy degrees). The obtained query gets extended
in a second rewriting step by (1) fuzzy atoms, (2) degree variables that capture
numerical membership degrees, and (3) numerical predicates that realize the
fuzzy operators. The resulting query can then be evaluated by a SQL engine.
This simple approach yields a sound and complete implementation only if fuzzy
semantics with the min operator for conjunction is employed as, for instance, the
popular Gödel semantics. For other semantics, at it will later be explained, our
approach remains complete but not sound. We have implemented this approach
in the FLite prototype, which uses the optimized Ontop reasoner to generate
the first rewriting.
In this paper we describe the pragmatic approach, introduce some optimiza-
tions of it and study the scalability of FLite—in particular the overhead intro-
duced by reasoning over fuzzy information. To this end we evaluate the FLite
implementation against Ontop for different (fuzzy) conjunctive queries per-
formed on a TBox and fuzzy ABoxes of different sizes. The benchmarks used
for the evaluation are based on a situation recognition application for complex
hard- and software systems.
The rest of the paper is structured as follows: Section 2 recalls DL-Lite R
and its fuzzy variant. Section 3 presents a description of the two-step rewriting
approach for answering fuzzy conjunctive queries and we discuss its limitations.
In Section 4 we examine optimizations for this approach, which are implemented
in FLite. Section 5 introduces our application of situation recognition that
motivates the two-step rewriting approach for querying crisp TBoxes with fuzzy
ABoxes and a benchmark from this application. The detailed evaluation of the
FLite system against Ontop is given in Section 6 for different ontology sizes and
different fuzzy queries. Conclusions and future work end the paper in Section 7.
2 Preliminaries
We start with DL-Lite R [2] and introduce its fuzzy variant [19, 10] afterwards.
Let the following be countably infinite and pairwise disjoint sets: NC of concept
names, NR of role names, NI of individual names, and NV of variable names. From
these sets the complex DL-Lite R -concepts, -roles and -queries are constructed.
DL-Lite R -concepts and -roles are defined according to the following grammar:
B →A | ∃Q C →> | B | ¬B Q →P | P − R →Q | ¬Q,
where > is the top concept, A ∈ NC , P ∈ NR . Based on these kinds of complex
concepts and roles, a DL-Lite R TBox T is a finite set of axioms of the form:
B v C, Q v R or f unct(Q). Let a, b ∈ NI and d ∈ [0, 1] a fuzzy degree. A fuzzy
assertion is of the forms: hB(a), > di or hP (a, b), > di. An ABox A is a finite
set of fuzzy assertions. A fuzzy DL-Lite-ontology O = (T , A) consists of a TBox
T and an ABox A. Please note that the TBoxes are always crisp in our setting.
Table 1. Families of fuzzy logic operators.
Family t-norm a⊗b negation a implication α ⇒ b
( (
1, a = 0 1, a 6 b
Gödel min(a, b)
0, a > 0 b, a > b
Lukasiewicz max(a + b − 1, 0) 1−a min(1 − a + b, 1)
( (
1, a = 0 1, a6b
Product a×b
0, a > 0 b/a, a > b
Crisp DL-Lite R -ontologies are a special case of fuzzy ones, where only degrees 1
and 0 are admitted.
The reasoning problem we address is answering of (unions of) conjunctive
queries. Let t1 , t2 ∈ NI ∪ NV be terms, an atom is an expression of the form:
C(t1 ) or P (t1 , t2 ). Let x and y be vectors over NV , then φ(x, y) is a conjunction
of atoms of the forms A(t1 ) and P (t1 , t2 ). A conjunctive query (CQ) q(x) over an
ontology O is a first-order formula ∃y.φ(x, y), where x are the answer variables,
y are existentially quantified variables and the concepts and roles in φ(x, y)
appear in O. Observe, that the atoms in a CQ do not contain degrees. A union
of conjunctive queries (UCQ) is a finite set of conjunctive queries that have the
same number of answer variables.
The semantics of fuzzy DL-Lite R is provided via the different families of
fuzzy logic operators depicted in Table 1 and interpretations. An interpretation
for fuzzy DL-Lite R is a pair I = (∆I , ·I ), where ∆I is as usual, but ·I is an
interpretation function mapping every
– a ∈ NI to some element aI ∈ ∆I ,
– A ∈ NC to a concept membership function AI : ∆I → [0, 1],
– P ∈ NR to a role membership function P I : ∆I × ∆I → [0, 1].
Let δ, δ 0 denote elements of ∆I and denote fuzzy negation (Table 1), then
the semantics of concepts and roles are inductively defined as follows:
(∃Q)I (δ) = supδ0 ∈∆I QI (δ, δ 0 ) (¬B)I (δ) = B I (δ) >I (δ) = 1
P −I (δ, δ 0 ) = P I (δ 0 , δ) (¬Q)I (δ, δ 0 ) = QI (δ, δ 0 )
An interpretation I satisfies B v C iff B I (δ) 6 C I (δ) for every δ ∈ ∆I , Q v R
iff QI (δ, δ 0 ) 6 RI (δ, δ 0 ) for every δ, δ 0 ∈ ∆I , and func(Q) iff for every δ ∈ ∆I
there is a unique δ 0 ∈ ∆I such that QI (δ, δ 0 ) > 0. An interpretation I is a model
of a TBox T , i.e. I |= T , iff it satisfies all axioms in T . I satisfies hB(a), > di
iff B I (aI ) > d, and hP (a, b), > di iff P I (aI , bI ) > d. I is a model of an ABox
A, i.e. I |= A, iff it satisfies all assertions in A. Finally an interpretation I is a
model of an ontology O = (T , A) iff it is a model of A and T .
Given a CQ q(x) = ∃y.φ(x, y), an interpretation I, a vector of individuals α
with the same arity as x, we define the mapping π that maps: i) each individual
a to aI , ii) each variable in x to an element of αI , and iii) each variable in y
to an element δ ∈ ∆I . Suppose that for an interpretation I, Π is the set of
mappings that comply to these three conditions. Computing the t-norm ⊗ of
all atoms: AI (π(t1 )) and P I (π(t1 ), π(t2 )) yields the degree of φI (αI , π(y)). A
tuple of individuals α is a certain answer to q(x), over O, with a degree greater
or equal than d (denoted O |= q(α) > d), if for every model I of O:
q I (αI ) = supπ∈Π {φI (α, π(y))} > d.
We denote the set of certain answers along with degrees, to a query q(x) w.r.t.
an ontology O with ans(q(x), O):
ans(q(x), O) = {(α, d) | O |= q(α) > d ∧ 6 ∃d0 .d0 > d ∧ O |= q(α) > d0 }.
To illustrate the use of the fuzzy DL-Lite R language and queries, we provide
an example from our application domain.
Example 1. The ontology Oex for our running example consists of:
Tex := {Server v ∃hasCPU, ∃hasCPU− v CPU, func(hasCPU− )}
Aex := {hServer(server1 ), > 1i, hhasCPU(server1 , cpu1 ), > 1i,
hOverUsed(cpu1 ), > 0.6i, hhasCPU(server1 , cpu2 ), > 1i,
hOverUsed(cpu2 ), > 0.8i }
The first two axioms in Tex state that each server has a part that is a CPU. The
third one states that no CPU can belong to more than one server. Aex provides
information about the connections between servers and CPUs and each CPU’s
degree of overuse. To query the ontology Oex we can formulate the queries:
q1 (x, y) = hasCPU(x, y) ∧ OverUsed(y)
q2 (x) = ∃y hasCPU(x, y) ∧ OverUsed(y)
The query q1 asks for pairs of Servers and CPUs with an overused CPU. The
query q2 asks for Servers, where the Server’s CPU is overused. If conjunction and
negation are interpreted as the Gödel family of operators, the certain answers
w.r.t. Oex are:
ans(q1 (x, y), Oex ) = {(server1 , cpu1 , 0.6), (server2 , cpu2 , 0.8)}
ans(q2 (x), Oex ) = {(server1 , 0.8)}.
3 Fuzzy Query Answering by Extended Crisp Rewritings
Let CQ q(x) be formulated over the vocabulary of the DL-Lite R ontology O =
(T , A). The main idea underlying the classic DL-Lite R query answering algo-
rithm is to rewrite the query q(x) with the information from the TBox T into
a UCQ qT (x) and then apply this UCQ to the ABox A alone [6, 2]. For fuzzy
DLs we extend this approach to handle degrees of ABox assertions. The main
idea is depicted in Figure 1. To explain the algorithm we need the predicates Af ,
Pf , and Φ⊗ . Intuitively, each binary predicate Af is an extension of the unary
predicate A such that the fuzzy concept assertion hA(a), > di is equivalent to
the predicate assertion Af (a, d) (similarly for Pf ). The n-ary predicate Φ⊗ is
adopted in order to realize the semantics of the fuzzy conjunction (e.g. mini-
mum for the Gödel norm) within a FOL query. Thus, for each tuple of degrees
d1 , . . . , dn ∈ [0, 1] such that d1 = ⊗(d2 , . . . , dn ), we have that (d1 , . . . , dn ) ∈ Φ⊗ .
Suppose now that the CQ q(x) is to be answered. The two-step rewriting algo-
rithm proceeds as follows:
1. The crisp DL-Lite R algorithm rewrites q(x) to qT (x). (For ease of presenta-
tion we assume that qT (x) is still a CQ.)
2. The fuzzy query qT ,f (x, xd ) is computed from qT (x) by replacing atoms
of the form A(t1 ) and P (t1 , t2 ) by Af (t1 , yd ) and Pf (t1 , t2 , yd ), where the
variable yd is a degree variable. Its purpose is to retrieve the degree of an
assertion. The degree value for fuzzy conjunction is retrieved by the predi-
cate Φ⊗ and (to be) stored in the additional degree variable xd . Thus, the
conjunction degree of a new atom qT ,f (x, xd ) is obtained by the predicate
Φ⊗ (xd , y1 , . . . , yn ), where yi is a degree variable in the ith atom of the CQ.
3. The query is evaluated over the ABox and the actual computation of the
degree values takes place. Now, for a tuple of individuals α and degrees
d1 , d2 ∈ [0, 1], if (α, d1 ) and (α, d2 ) are both answers to the query, only the
answer with the higher degree is returned.
Note that this description abstracts from the fact that the ABox A is usually
implemented by a relational database D and a mapping M. We see in Section 3.1
how this mapping is extended to incorporate fuzzy information. For a more
detailed presentation of the algorithms, the reader may refer to [9].
Example 2. We return to Example 1 and illustrate the application of the algo-
rithm to the queries. Initially, q1 and q2 are rewritten to the following UCQs:
q1 Tex (x, y) ={hasCPU(x, y) ∧ OverUsed(y)}
q2 Tex (x) ={∃y.hasCPU(x, y) ∧ OverUsed(y)}
FLITE Reasoner
Fig. 1. The process flow diagram of the FLite rewriting procedure.
In the next step, the algorithm extends the queries with degree variables and
atoms, so that the corresponding degrees can be returned:
q1 fTex (x, y, xd ) ={hasCPU(x, y, yd1 ) ∧ OverUsed(y, yd2 ) ∧ Φ⊗ (xd , yd1 , yd2 )}
q2 fTex (x, xd ) ={∃y.hasCPU(x, y, yd1 ) ∧ OverUsed(y, yd2 ) ∧ Φ⊗ (xd , yd1 , yd2 )}
For the ABox Aex the following set of answers to each of the queries are returned:
ans(q1 fTex (x, xd ), Aex ) ={(server1 , cpu1 , 0.6), (server1 , cpu2 , 0.8)}
ans(q2 fTex (x, xd ), Aex ) ={(server1 , 0.8)}.
The limitations of our pragmatic approach are explained in [9]. To sum up,
our approach yields sound and complete results for fuzzy semantics based on
the min t-norm operator such as the Gödel family of operators. The correct-
ness for this case can be derived from the crisp DL-Lite R proof along with the
following points: (1) only crisp TBox axioms are allowed, (2) conjunctions only
appear in conjunctive query expressions, (3) Ontop optimizations do not af-
fect the correctness of the algorithm due to the properties of the min operator.
To illustrate the last point a conjunctive query qT (x) := A(x) ∧ A(x) is sim-
plified by Ontop to qT (x) := A(x). This simplification is correct for the min
operator since min(AI (δ), AI (δ)) = AI (δ) (for every interpretation I and every
δ ∈ ∆I ) . The latter does not apply for other t-norms, therefore the proposed
methodology is complete but not sound for the Lukasiewicz and Gödel families
of operators. Nevertheless, as described in [9], we devised a method by which
each unsound answer can be identified and its correct degree estimated between
two membership values. I.e. our algorithm asserts that for some d ∈ [0.7, 0.8],
(server1 , d) ∈ ans(q3 fTex (x, xd ), Aex ).
3.1 The FLite Reasoner Implementation
FLite4 (Fuzzy DL-Lite R query engine) implements the presented query answer-
ing algorithm and builds on the Ontop framework [14]. On a technical level, the
rewriting procedure becomes more involved when a reasoner such as Ontop is
deployed, since such systems are build to operate on relational databases. Thus
the queries qT (x) and qT ,f (x, xd ) in Figure 1 are SQL queries, while the ABox
A is derived from a partial mapping:
M : SQL SELECT Statements → ABox assertions.
In order to embed fuzzy information into mappings we adopt a reification ap-
proach sketched in the following example.
Example 3. We consider a fuzzy mapping described in the Quest syntax [13].
In this mapping, for the concept popularVideo each id of the table videos is
4
The FLite reasoner is available from the following Git: https://iccl-share.inf.tu-
dresden.de/flite-developer/flite.git
annotated with a popularity, i.e. a fuzzy degree:
t a r g e t haec : v i d e o { p o p u l a r i t y d e g r e e } a haec : PopularVideo .
s o u r c e SELECT f u z z y ( id , p o p u l a r i t y )
AS popularity degree
FROM videos
Now, if a video with an id of 12 and a popularity of 0.8 appears in the database,
then this corresponds to hPopularVideo(videos12), > 0.8i stated in the ontology.
The function fuzzy(column, degree) is a marker for the FLite parser to recognize
fuzzy statements. It indicates that every element of the particular column (or
SQL expression) gets a fuzzy degree assigned. This degree can either be a column
with values in [0, 1], or an SQL expression corresponding to a fuzzy membership
function. It should be noted that SQL expressions containing the fuzzy marker
function appear in the initial mapping M and in qT (x) queries while these
markers are converted in qT ,f (x, xd ) queries to a SQL expressions that return
the membership degree.
4 Optimizations for the FLite Implementation
Implementing the pragmatic approach naively would be very inefficient. First,
in contrast to Ontop’s rewritings, the “fuzzy” SQL query resulting from the
FLite rewriting process is not optimized for fast execution. Thus, the query
engine retrieves the same items multiple times. Second, the database contains
numerical values, that are mapped to coarser categories with membership degrees
at query execution time. These overheads can be reduced by optimizing the fuzzy
rewritings and fuzzifying numerical values in the database on a preprocessing
step. These optimizations are discussed in the following.
Self-join Removal (SR). Ontop performs a restructuring of query rewritings as
outlined in [15, 7]. Due to the reification process for embedding fuzzy informa-
tion, some of the optimizations performed by Ontop are obscured by the fuzzy
pseudo-function. Currently, Ontop appears to omit the optimization step, if an
unknown function is found in the query. Thus, its optimizer is not aware of the
fact that the fuzzy function is exclusively used by FLite to tag fuzzy degrees in
the query. Extending the process shown in Figure 1, the query optimizer should
be applied to the query qT ,f (x, xd ), e.g. to remove self-joins. To illustrate the
problem, consider a query qT ,f that contains self-joins of the following form:
SELECT a . column a , a . d e g r e e a , b . column b
FROM t a b l e A as a ,
INNER JOIN t a b l e A as b ON a . column a=b . column a
It can easily be verified that this query contains redundant selection statements
over the same database table and can be simplified to:
SELECT column a , d e g r e e a , column b FROM t a b l e A
The second query is performed in linear time w.r.t. the size of table A, while the
first one is performed in quadratic time. Indeed, we observed a huge improvement
on query execution time, depending on the number of tables that are self-joined.
Pre-computation of Membership Degrees (PD). Calculation of membership de-
grees of numerical values during query execution can lead to significant run-time
overhead depending on the complexity of the applied membership function. The
following listing shows an SQL statement where fuzzy degrees are assigned to
the values of a column by the membership degree function f :
SELECT f u z z y ( column a , f ( column b ) ) FROM c r i s p t a b l e
The case where membership degrees are available directly , reduces the overhead
of calling and executing such a function. In the following SQL statement, function
f was replaced by a membership degree column.
SELECT f u z z y ( column a , membership degree column )
FROM f u z z y t a b l e
For simple mappings of this form, database schema restructuring is unnecessary,
since the observed raw data in our application database are often numerical val-
ues, an automatic mechanism that translates these values to membership degrees
is necessary. For this purpose we introduce computed or virtual columns, which
contain values that are computed by a user-defined membership function, which
is triggered when a new row is added to the table. This avoids the overhead for
the computation of membership function during the evaluation of the rewritten
query at the cost of an increase in database size and membership function over-
head during the database update process. In the end he FLite user has to assess
on the basis of the mapping whether to spend more time for query execution or
more disc space for additional fuzzy columns.
5 A Sample Application: Situation Recognition
The project “Highly Adaptive Energy-efficient Computing” (HAEC) investigates
complex computing environments that are highly energy-efficient while compro-
mising utility of services as little as possible. In order to be adaptive, the system
needs to trigger adaptations (of hard- or software components), if the quality of
the requested services or their number changes. To provide such a trigger mech-
anism we investigate an ontology-based situation recognition. The situations to
be recognized are modelled as conjunctive queries. The background information
on the system is captured in the TBox and the current system’s state is cap-
tured by an ABox. Such ABoxes are automatically generated from sensor data
and other systems information and the conjunctive queries for the situations are
evaluated. In such a setting the numerical sensor data need to be mapped to
coarser, symbolic categories and membership degrees. Similarly, the query needs
to be able to retrieve individuals that fulfill the conditions of the query to a
degree. We have built a TBox and a collection of ABoxes and queries for this
application.
5.1 Towards a Benchmark
The hard- and software components of the HAEC system are modeled in a TBox
which consists of 197 GCIs, 168 named classes and 38 roles (415 axioms total).
Each state of the HAEC system is stored in tables of a relational database.
This database stores the information on the soft- and hardware of the HAEC
system. The tables contain numerical values for boards, processes, requests, etc.5
Identifying the HAEC ontology as TBox and the HAEC database as ABox, this
benchmark compares the run-time to answer (fuzzy) conjunctive queries over
TBox and ABox by Ontop and FLite. In contrast to Ontop which requires a
crisp mapping, FLite is using a partially fuzzy mapping.
6 Results of FLite on the Benchmark
FLite was evaluated over a series of variations of the HAEC benchmarks. The
number of additional atoms in the conjunctive query n and the database scale
factor k were increased in the series.
The initial database with a size of 768.0 KiB was scaled by k in the range
of 100 to 105 to about 13 GiB by the Virtual Instance Generator (VIG) [8]. For
each of these scaled databases, the number of atoms of the initial conjunctive
query (2 concepts, 4 roles) was increased by n additional atoms from one atom
to a maximum of seven (13 atoms total). The system on which the benchmark
was performed on is powered by an Intel Core i7 2.6 GHz processor and was
equipped with 8 GB DDR 1600 main memory. ABox information was stored in
a MySQL 5.6.23 database. FLite and Ontop are executed on Oracle the JVM
1.7.
Figure 2 shows the query execution time of Ontop for a query with seven
additional atoms and with a crisp mapping compared to the naive FLite imple-
mentation for a query with one to seven additional atoms with fuzzy mapping
using Gödel t-norms for an increasing database size.
FLite needs longer run-time in the order of almost two magnitudes compared to
the one of Ontop. Therefore, it is vital that the naive FLite implementation is
enhanced by optimization techniques. Employing the optimizations introduced
in Section 4 results in the query execution times displayed in Figure 3.
Optimization SR in Figure 3 shows run-time reduction up to a scale factor of
about thousand, then it converges with the naive FLite implementation. Thus,
an optimization that also effect larger databases is necessary. Optimization PD
in Figure 3 shows opposite behavior, resulting in a run-time reduction from a
scale factor of thousand. Finally, a combination of both reduces the run-time on
all scale factors and is even on the same level with Ontop up to a scale factor
of thousand. Thus, a query execution time with a flat linear run-time overhead
with respect to Ontop is possible when the fuzzy rewriting is optimized and
fuzzy translation functions are replaced by fuzzy computed columns.
5
The files necessary to perform this benchmark can be found here: https://iccl-
share.inf.tu-dresden.de/erikzenker/flite-benchmark.git
avg. query execution time [ms]
1x106
FLite naive n=7
100000 FLite naive n=6
FLite naive n=5
10000
FLite naive n=4
1000 FLite naive n=3
FLite naive n=2
100
FLite naive n=1
10 Ontop n=7
1
1 10 100 1000 10000 100000
database scale factor k
Fig. 2. Query execution time of Ontop with seven additional atoms with crisp mapping
compared to the naive FLite implementation with one to seven additional atoms with
fuzzy mapping.
avg. query execution time [ms]
1x106
Ontop n=7
100000 FLite naive n=7
Optimization SR n=7
10000
Optimization PD n=7
1000 Optimization SR+PD n=7
100
10
1
1 10 100 1000 10000 100000
database scale factor k
Fig. 3. Ontop is compared to optimized FLite versions SR, PD, and SR+PD. All
setups were executed over a CQ with seven additional atoms.
Instead of comparing FLite with Ontop, a comparison with other fuzzy
DL reasoners would have been desirable. However, reasoners such as LiFR [21],
FuzzyDL [4], FiRE [17], and DeLorean [3] support only instance checking rather
than conjunctive query answering (albeit for more expressive DLs than DL-Lite R ).
Others such as the DL-Lite reasoner Ontosearch2 [11] or SoftFacts [20] could
either not be obtained or installed. Thus we had to resort to Ontop for a com-
parison for query answering in DL-Lite R .
7 Conclusions
We presented a pragmatic approach for answering fuzzy conjunctive queries over
DL-Lite R -ontologies with fuzzy ABoxes. Our approach uses rewritings obtained
by the algorithm for answering crisp queries as an intermediate step and thus
allows to make use of standard query rewriting engines. Although described
here for DL-Lite R , our approach can be extended to other DLs that enjoy FOL
rewritability. Our algorithm is sound for those t-norms that have idempotent
operators, such as the Gödel t-norm.
We implemented our approach in the FLite system and evaluated it against
the Ontop reasoner for ABoxes of varying size. Our evaluation gave evidence
that there is a substantial increase of run-time for large ABoxes, when fuzzy
information is queried. This increase can be reduced by basic optimizations.
However, developing and extending FLite is on-going work.
References
1. A. Acciarri, D. Calvanese, G. De Giacomo, D. Lembo, M. Lenzerini, M. Palmieri,
and R. Rosati. QUONTO: Querying Ontologies. In AAAI, pages 1670–1671, 2005.
2. A. Artale, D. Calvanese, R. Kontchakov, and M. Zakharyaschev. The DL-Lite
Family and Relations. Journal of artificial intelligence research, 36(1):1–69, 2009.
3. F. Bobillo, M. Delgado, and J. Gómez-Romero. Reasoning in Fuzzy OWL 2 with
DeLorean. In Uncertainty Reasoning for the Semantic Web II, pages 119–138.
2013.
4. F. Bobillo and U. Straccia. fuzzyDL: An Expressive Fuzzy Description logic Rea-
soner. In FUZZ-IEEE, pages 923–930, 2008.
5. D. Calvanese, G. De Giacomo, D. Lembo, M. Lenzerini, A. Poggi, M. Rodriguez-
Muro, and R. Rosati. Ontologies and Databases: The DL-Lite Approach. 2009.
6. D. Calvanese, G. De Giacomo, D. Lembo, M. Lenzerini, and R. Rosati. Tractable
Reasoning and Efficient Query Answering in Description Logics: The DL-Lite Fam-
ily. Journal of Automated reasoning, 39, 2007.
7. R. Kontchakov, M. Rezk, M. Rodrı́guez-Muro, G. Xiao, and M. Zakharyaschev.
Answering SPARQL Queries over Databases under OWL 2 QL Entailment Regime.
In The Semantic Web–ISWC 2014, pages 552–567. Springer, 2014.
8. D. Lanti, M. Rezk, M. Slusnys, G. Xiao, and D. Calvanese. The NPD Benchmark
for OBDA Systems. In 10th International Workshop on Scalable Semantic Web
Knowledge Base Systems (SSWS 2014), page 3, 2014.
9. T. Mailis and A.-Y. Turhan. Employing DL-LiteR -Reasoners for Fuzzy Query
Answering. In Proceedings of the 4th Joint International Semantic Technology
Conference (JIST2014), LNCS, 2014.
10. J. Z. Pan, G. B. Stamou, G. Stoilos, and E. Thomas. Expressive Querying over
Fuzzy DL-Lite Ontologies. In Description Logics, 2007.
11. J. Z. Pan, E. Thomas, and D. Sleeman. Ontosearch2: Searching and querying web
ontologies. Proc. of WWW/Internet, 2006:211–218, 2006.
12. A. Poggi, M. Rodriguez, and M. Ruzzi. Ontology-based database access with DIG-
Mastro and the OBDA Plugin for Protégé. In Proc. of OWLED, 2008.
13. M. Rodriguez-Muro, J. Hardi, and D. Calvanese. Quest: Efficient SPARQL-to-SQL
for RDF and OWL. In 11th International Semantic Web Conference ISWC 2012,
page 53, 2012.
14. M. Rodriguez-Muro, R. Kontchakov, and M. Zakharyaschev. Ontology-Based Data
Access: Ontop of Databases. In International Semantic Web Conference (1), vol-
ume 8218 of LNCS, pages 558–573. Springer, 2013.
15. M. Rodriguez-Muro, M. Rezk, J. Hardi, M. Slusnys, T. Bagosi, and D. Calvanese.
Evaluating SPARQL-to-SQL Translation in Ontop. In Informal Proceedings of
ORE’13, pages 94–100, 2013.
16. M. Stocker and M. Smith. Owlgres: A Scalable OWL Reasoner. In OWLED,
volume 432, 2008.
17. G. Stoilos, N. Simou, G. Stamou, and S. Kollias. Uncertainty and the Semantic
Web. Intelligent Systems, 21(5):84–87, 2006.
18. U. Straccia. Answering Vague Queries in Fuzzy DL-Lite. In Proceedings of the
11th International Conference on Information Processing and Management of Un-
certainty in Knowledge-Based Systems,(IPMU-06), pages 2238–2245, 2006.
19. U. Straccia. Towards Top-k Query Answering in Description Logics: The Case of
DL-Lite. In Logics in Artificial Intelligence, pages 439–451. Springer, 2006.
20. U. Straccia. SoftFacts: A Top-k Retrieval Engine for Ontology Mediated Access
to Relational Databases. In Systems Man and Cybernetics (SMC), 2010 IEEE
International Conference on, pages 4115–4122. IEEE, 2010.
21. D. Tsatsou, S. Dasiopoulou, I. Kompatsiaris, and V. Mezaris. LiFR: A Lightweight
Fuzzy DL Reasoner. In The Semantic Web: ESWC 2014 Satellite Events, pages
263–267. 2014.
22. T. Venetis, G. Stoilos, and G. Stamou. Query Extensions and Incremental Query
Rewriting for OWL 2 QL Ontologies. Journal on Data Semantics, pages 1–23,
2014.