A Pragmatic Approach to Answering CQs over Fuzzy DL-Lite -ontologies{introducing FLite ?

Abstract

Fuzzy Description Logics (FDLs) generalize crisp ones by providing membership degree semantics. To o er e cient query answering 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-LiteR ontologies we present an approach, that employs the crisp rewriting as a black-box procedure and treats the degrees in a second rewriting step. This pragmatic approach yields a sound procedure for the Godel based fuzzy semantics, which we have implemented in the FLite reasoner that employs the Ontop system. A rst evaluation of FLite suggests that one pays only a linear overhead for fuzzy queries.

Introduction

Fuzzy variants of Description Logics (DLs) were introduced in order to describe concepts for which there exists no sharp, unambiguous distinction between members and nonmembers. For example, a natural way to model a component running 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 answering can be done e ciently |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 optimizations 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-LiteRTBoxes and fuzzy DL-LiteR-ABoxes, that takes advantage of these optimizations, was presented in [ 9 ]. The combination of crisp TBoxes with fuzzy ABoxes is useful in applications, where only the data is imprecise, while the terminological knowledge is not, e.g., as in situation recognition applications that rely on sensor data.

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 Godel 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 rst rewriting.

In this paper we describe the pragmatic approach, introduce some optimizations of it and study the scalability of FLite|in particular the overhead introduced by reasoning over fuzzy information. To this end we evaluate the FLite implementation against Ontop for di erent (fuzzy) conjunctive queries performed on a TBox and fuzzy ABoxes of di erent 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-LiteR 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 di erent ontology sizes and di erent fuzzy queries. Conclusions and future work end the paper in Section 7. 2

Preliminaries

We start with DL-LiteR [ 2 ] and introduce its fuzzy variant [ 19, 10 ] afterwards. Let the following be countably in nite 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-LiteR-concepts, -roles and -queries are constructed. DL-LiteR-concepts and -roles are de ned according to the following grammar: B !A j 9Q

C !> j B j :B

Q !P j P

R !Q j :Q; where > is the top concept, A 2 NC, P 2 NR. Based on these kinds of complex concepts and roles, a DL-LiteR TBox T is a nite set of axioms of the form: B v C, Q v R or f unct(Q). Let a; b 2 NI and d 2 [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 nite 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. Crisp DL-LiteR-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 2 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 rst-order formula 9y: (x; y), where x are the answer variables, y are existentially quanti ed 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 nite set of conjunctive queries that have the same number of answer variables.

The semantics of fuzzy DL-LiteR is provided via the di erent families of fuzzy logic operators depicted in Table 1 and interpretations. An interpretation for fuzzy DL-LiteR is a pair I = ( I ; I ), where I is as usual, but I is an interpretation function mapping every { a 2 NI to some element aI 2 I , { A 2 NC to a concept membership function AI : I ! [0; 1], { P 2 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 de ned as follows: (9Q)I ( ) = sup 02 I QI ( ; 0) P I ( ; 0) = P I ( 0; )

(:B)I ( ) = (:Q)I ( ; 0) =

BI ( ) QI ( ; 0) >I ( ) = 1 An interpretation I satis es B v C i BI ( ) 6 CI ( ) for every 2 I , Q v R i QI ( ; 0) 6 RI ( ; 0) for every ; 0 2 I , and func(Q) i for every 2 I there is a unique 0 2 I such that QI ( ; 0) > 0. An interpretation I is a model of a TBox T , i.e. I j= T , i it satis es all axioms in T . I satis es hB(a); > di i BI (aI ) > d, and hP (a; b); > di i P I (aI ; bI ) > d. I is a model of an ABox A, i.e. I j= A, i it satis es all assertions in A. Finally an interpretation I is a model of an ontology O = (T ; A) i it is a model of A and T .

Given a CQ q(x) = 9y: (x; y), an interpretation I, a vector of individuals with the same arity as x, we de ne 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 2 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 j= q( ) > d), if for every model I of O: qI ( I ) = sup 2 f I ( ; (y))g > 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) = f( ; d) j O j= q( ) > d ^ 6 9d0:d0 > d ^ O j= q( ) > d0g: To illustrate the use of the fuzzy DL-LiteR language and queries, we provide an example from our application domain.

Example 1. The ontology Oex for our running example consists of: Tex := fServer v 9hasCPU; 9hasCPU v CPU; func(hasCPU )g Aex := fhServer(server1); > 1i; hhasCPU(server1; cpu1); > 1i; hOverUsed(cpu1); > 0:6i; hhasCPU(server1; cpu2); > 1i; hOverUsed(cpu2); > 0:8i g The rst 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) = 9y 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 Godel family of operators, the certain answers w.r.t. Oex are: ans(q1(x; y); Oex) = f(server1; cpu1; 0:6); (server2; cpu2; 0:8)g

ans(q2(x); Oex) = f(server1; 0:8)g: 3

Fuzzy Query Answering by Extended Crisp Rewritings Let CQ q(x) be formulated over the vocabulary of the DL-LiteR ontology O = (T ; A). The main idea underlying the classic DL-LiteR query answering algorithm 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. minimum for the Godel norm) within a FOL query. Thus, for each tuple of degrees d1; : : : ; dn 2 [0; 1] such that d1 = (d2; : : : ; dn), we have that (d1; : : : ; dn) 2 . Suppose now that the CQ q(x) is to be answered. The two-step rewriting algorithm proceeds as follows: 1. The crisp DL-LiteR algorithm rewrites q(x) to qT (x). (For ease of presentation 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 predicate 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 2 [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 algorithm to the queries. Initially, q1 and q2 are rewritten to the following UCQs: q1Tex (x; y) =fhasCPU(x; y) ^ OverUsed(y)g

q2Tex (x) =f9y:hasCPU(x; y) ^ OverUsed(y)g

FLITE Reasoner

In the next step, the algorithm extends the queries with degree variables and atoms, so that the corresponding degrees can be returned: q1fTex (x; y; xd) =fhasCPU(x; y; yd1 ) ^ OverUsed(y; yd2 ) ^ q2fTex (x; xd) =f9y:hasCPU(x; y; yd1 ) ^ OverUsed(y; yd2 ) ^ (xd; yd1 ; yd2 )g (xd; yd1 ; yd2 )g For the ABox Aex the following set of answers to each of the queries are returned: ans(q1fTex (x; xd); Aex) =f(server1; cpu1; 0:6); (server1; cpu2; 0:8)g ans(q2fTex (x; xd); Aex) =f(server1; 0:8)g:

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 Godel family of operators. The correctness for this case can be derived from the crisp DL-LiteR 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 affect 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 simpli ed by Ontop to qT (x) := A(x). This simpli cation is correct for the min operator since min(AI ( ); AI ( )) = AI ( ) (for every interpretation I and every 2 I ) . The latter does not apply for other t-norms, therefore the proposed methodology is complete but not sound for the Lukasiewicz and Godel families of operators. Nevertheless, as described in [ 9 ], we devised a method by which each unsound answer can be identi ed and its correct degree estimated between two membership values. I.e. our algorithm asserts that for some d 2 [0:7; 0:8], (server1; d) 2 ans(q3fTex (x; xd); Aex). 3.1

The FLite Reasoner Implementation FLite4 (Fuzzy DL-LiteR query engine) implements the presented query answering 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 rei cation approach 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.tudresden.de/ ite-developer/ ite.git annotated with a popularity, i.e. a fuzzy degree: t a r g e t h a e c : v i d e o f p o p u l a r i t y d e g r e e g a h a e c : P o p u l a r V i d e o . s o u r c e SELECT f u z z y ( i d , p o p u l a r i t y )

AS p o p u l a r i t y d e g r e e

FROM v i d e o s 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 ine cient. 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 rei cation process for embedding fuzzy information, 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 . c o l u m n a=b . c o l um n a It can easily be veri ed that this query contains redundant selection statements over the same database table and can be simpli ed 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 rst 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 degrees of numerical values during query execution can lead to signi cant 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 , m e m b e r s h i p d e g r e e c o l u m n ) 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 values, 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-de ned 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 overhead 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-e cient Computing" (HAEC) investigates complex computing environments that are highly energy-e cient while compromising 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 mechanism 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 captured 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 ful ll the conditions of the query to a degree. We have built a TBox and a collection of ABoxes and queries for this application. 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. 5 The les necessary to perform this benchmark can be found here: https://icclshare.inf.tu-dresden.de/erikzenker/ ite-benchmark.git 100 1000 database scale factor k 10000 100000

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-LiteR). 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 comparison for query answering in DL-LiteR. 7

Conclusions

We presented a pragmatic approach for answering fuzzy conjunctive queries over DL-LiteR-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-LiteR, 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 Godel 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. 19. U. Straccia. Towards Top-k Query Answering in Description Logics: The Case of

DL-Lite. In Logics in Arti cial 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.

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 arti cial intelligence research , 36 ( 1 ):1{ 69 , 2009 .

3. F. Bobillo , M. Delgado , and J. Gomez-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 Reasoner . In FUZZ-IEEE , pages 923 { 930 , 2008 .

5. D. Calvanese , G. De Giacomo, D. Lembo , M. Lenzerini , A. Poggi , M. RodriguezMuro, 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 E cient Query Answering in Description Logics: The DL-Lite Family . 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 DIGMastro and the OBDA Plugin for Protege . In Proc. of OWLED , 2008 .

13. M. Rodriguez-Muro , J. Hardi , and D. Calvanese . Quest: E cient 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) , volume 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 Uncertainty in Knowledge-Based Systems,(IPMU-06) , pages 2238 { 2245 , 2006 .