Mapping Data to Ontologies with Exceptions Using Answer Set Programming

Mapping Data to Ontologies with Exceptions Using Answer Set Programming

Daniel P. Lupp    Evgenij Thorstensen
University of Oslo, Norway
{danielup, evgenit}@ifi.uio.no
Abstract

In ontology-based data access, databases are connected to an ontology via mappings from queries over the database to queries over the ontology. In this paper, we consider mappings from relational databases to first-order ontologies, and define an ASP-based framework for GLAV mappings with queries over the ontology in the mapping rule bodies. We show that this type of mappings can be used to express constraints and exceptions, as well as being a powerful mechanism for succinctly representing OBDA mappings. We give an algorithm for brave reasoning in this setting, and show that this problem has either the same data complexity as ASP (NP-complete), or it is at least as hard as the complexity of checking entailment for the ontology queries. Furthermore, we show that for ontologies with UCQ-rewritable queries there exists a natural reduction from mapping programs to -ASP, an extension of ASP with existential variables that itself admits a natural reduction to ASP.

Mapping Data to Ontologies with Exceptions Using Answer Set Programming


Daniel P. Lupp and Evgenij Thorstensen University of Oslo, Norway {danielup, evgenit}@ifi.uio.no

Introduction

Ontology-based data access (OBDA) (?) is a method for data integration, utilizing a semantic layer consisting of an ontology and a set of mappings on top of a database. An ontology is a machine-readable model designed to faithfully represent knowledge of a domain independently of the structure of the database; it is comprised of concepts and relationships between these concepts. These ontologies are often formulated using description logics (DLs), a class of decidable logics, due to their desirable computational properties (?).

With the help of mappings, users’ queries over the ontology are rewritten into a query over the database language, such as SQL, which can then be run on the source data. This query rewriting consists of two stages: Firstly, the ontology query is rewritten to an equivalent query which takes ontological knowledge into account. Secondly, the mappings are used to translate this query into the source query language. To ensure that this rewriting is always possible, one requires the ontology to be first-order rewritable (FOL-rewritable); that is, that every rewritten query is equivalent to a first-order formula. However, not all description logics have this property. A common class of ontology languages used in OBDA is the DL-lite family. These description logics have been tailored towards FOL-rewritability and tractable query answering, making them ideally suited for OBDA (?).

Unfortuantely, the rewriting step can cause a worst-case exponential blow-up in query size (?). While this blow-up is necessary to ensure complete query answering, it can lead to highly redundant database queries, where the same data is accessed multiple times. Furthermore, mapping design and maintenance is usually manual work (?). This can be a very laborious task, and recent work on mapping evolution and repair (?) attempt to alleviate some of the difficulties involved. However, currently OBDA mappings are interpreted as first-order implications. As a consequence, they lack the expressivity to efficiently handle these issues: exceptions must be stated explicitly, possibly in multiple mapping assertions. Furthermore, pruning redundant queries without nonmonotonic features such as extensional constraints (?) or closed predicates (?) is practically infeasible.

Current research on extending OBDA with nonmonontonic capabilities has focused on the ontology side, e.g., through modal description logics or by inclusion of closed predicates (??). However the modal semantics can be quite unintuitive. In this setting, modal ontology axioms do not behave well with nonmodal axioms. Furthermore, research into extending ontologies with closed predicates quickly results in intractability (?) .

There have also been several approaches to combining rule-based formalisms and description logic ontologies, be it by constructing a hybrid framework integrating both rules and ontology axioms into the same semantics (?) or by adding rules “on top” (?) of ontologies. Here, the two formalisms retain different semantics, allowing, however, for interaction between rules and ontologies by including special predicates in the rule bodies.

In this paper, we propose a new framework for OBDA mappings, called mapping programs, based on stable model semantics, where mappings are not interpreted as first-order implications. Instead, mappings are rules containing (positive and negative) ontology queries in their bodies, allowing for existential quantification in the body and head of a rule. Each mapping rule contains a database query acting as a guard on the rule, hence existential witnesses generated by mapping rules are not further propagated by the mapping program. This is in contrast to the more general existential rules frameworks of tuple-generating dependencies (??), where existentials in heads of rules may propagate. The decidability of mapping program reasoning therefore reduces entirely to decidability of ontology reasoning.

This formalism allows expressing epistemic constraints on the database, such as extensional constraints (?). Furthermore, by being able to express default rules, mapping programs serve as a powerful abbreviation tool for mapping maintenance. This allows for adding nonmonotonic features to OBDA while retaining the desirable complexity of ontology reasoning. Mapping programs are a natural extension of -ASP (?), an extension of standard answer set programming (ASP) with existential quantifiers in the heads and negative bodies of rules.

In the following, we define and analyze the general mapping program framework, discussing reasoning complexity (NP-complete, where is an ontology reasoning oracle). We also consider a special case where the body ontology queries are UCQ-rewritable with respect to the ontology. In this setting, mapping programs can be equivalently reduced to classical ASP. Thus, efficient ASP solvers can be employed for query answering over mapping programs.

Preliminaries

OBDA Mappings

Let and be disjoint signatures containing ontology predicate symbols, and source predicate symbols respectively. Furthermore, let be a set of constants. Then a source schema is a relational schema containing relational predicates in as well as integrity constraints. A legal database instance over is a set of ground atoms from and that satisfies all integrity constraints in . A first-order formula with free variables is called a query, if it has no free variables it is called a boolean query. An ontology is a set of first-order formulas over . In practice, description logics are often used to express ontologies. Thus, though the results in this paper focus on the general case of FOL ontologies, we will use common DL notation throughout the examples in this paper for notational convenience (?).

Example 1.

The ontology axiom is equivalent to the first-order formula . Here, refers to the inverse role of .

Following (?), an OBDA specification is a tuple consisting of a database instance legal over a schema , a FOL-rewritable ontology and a set consisting of mapping assertions of the form , where and are queries over the data source and ontology, respectively. Then a model of an OBDA specification is a first-order model over that satisfies both and . Here we say that a first-order model satisfies a mapping if for every mapping assertion and every tuple .

Example 2.

Consider a database consisting of precisely one two-column table JOBS_DB(<NAME>,<JOB>). Furthermore, consider the following ontology:

Suppose that we simply wish to query for all instances of in the database. In the rewriting process, the query would be rewritten to

while in the unfolding step, each of the above disjuncts would be expanded to a database query using the mapping assertions. For example, if there exist two mapping assertions and , then the disjunct would be unfolded as .

Example 2 demonstrates some of the current shortcomings of OBDA: due to its inherent, first-order nature, it is impossible to distinguish between inferred knowledge and knowledge that is explicit in the database. In the above example, in the presence of a mapping assertion the query would have sufficed without any ontology rewriting, since all desired information was contained in one table. However, while some OBDA implementations (?) support manual query pruning, i.e., the user is able to decide which concepts should not be rewritten, this can potentially lead to incomplete query answering, and there is currently no way of formally checking whether it does. Thus, to ensure complete query answering we have a (potentially redundant) worst-case exponential blow-up in query size.

Another issue with the current aproach is how exceptions and a lack of information are dealt with. Currently, one must keep track of exceptions manually by explicitly listing all exceptions to a rule. Furthermore, due to the closed-world assumption (CWA) in the database, a lack of knowledge is interpreted as knowledge itself, e.g., if something is not contained in the JOBS_DB table, it is not a .

Answer Set Programming

Answer set programming (ASP) is a declarative programming paradigm based on the stable model semantics first defined in (?) as a means of handling default negation in a straightforward manner. It has become one of the more popular logic programming paradigms, due to, e.g., computational benefits such as guaranteed termination as compared to resolution in Prolog (?).

An ASP-program s a set of rules of the form

with ground atoms and . The head of a rule is and the body consists of a two parts, the negative body and the positive body . The Herbrand base of a program is the set of all possible ground atoms using predicate symbols, function symbols and constants occuring in . Then for a subset , the Gelfond-Lifschitz reduct of is the set of rules in after applying the following changes:

  1. If for some , remove the rule (this corresponds to rules that cannot be applied)

  2. In all remaining rules, remove the negative clauses (this corresponds to removing all negative clauses that will evaluate to true)

This reduct is a positive program, i.e., a program without any occurence of negation-as-failure. An interpretation is called a stable model or an answer set of if it is a -minimal model of , i.e., it is -minimal and satisfies all rules in .

Though the above semantics require ground atoms, i.e., are essentially propositional, ASP programs might also contains variables or function symbols. In this general case where function symbols are allowed, reasoning becomes undecidable (?). In the function-free case, the first-order ASP programs are usually first grounded to reduce it to the propositional case. The grounded programs can then either be solved directly (?) or, e.g., translated to SAT before being passed on to efficient SAT solvers (??).

-Asp

-ASP is an extension to answer set programming proposed by (?) to include existential quantification in both the heads and negative bodies of rules. These existential variables are dealt with by Skolemizing and treating the newly introduced function symbols as constants. Specifically, an -rule is a rule of the form

where all are atoms. Then, all variables not occuring in the positive body of a rule are interpreted existentially. Thus, the Skolem program of an -program is defined as the set of rules obtained from by replacing each existential variable in the head of a rule by a Skolem symbol.

Similar to standard ASP, this program is then grounded; one must, however, be careful with existential variables in the negative bodies, as the complete grounding is not equivalent to the nonground rules.To address this, (?) introduce the concept of partial grounding, which grounds all variables except the existentials in the negative body. The reduct is then defined analogously to the standard ASP case: Given a set of ground atoms , first remove all rules containing a negative body atom which is entailed by . Finally, remove all remaining negative body atoms.

An -answer is then defined in the usual way, now also allowing for Skolem symbols in place of constants: a set is called an -answer set iff it is a minimal model of the reduct .

By adding a set of auxiliary predicates to the signature of an -ASP program , one is able to rewrite into a classical ASP program such that they are equivalent with respect to answer sets. In particular, for an -answer set of there exists some set of ground atoms over predicates in such that is a classical answer set of . Furthermore, from an answer set of one can construct an -answer set of by removing any ground atoms over predicates in occuring in (for more details on the rewriting, see Proposition 8 and the preceding discussion in (?)). Therefore, reasoning in -ASP can be reduced to reasoning in classical ASP.

OBDA Mapping Programs

In this section we introduce the syntax and semantics for a new framework for OBDA mappings called mapping programs. These programs consist of rules that, intuitively, map database queries to ontology queries provided that certain conditions and are met. Thus, mapping programs extend classical OBDA mappings with default reasoning.

Syntax

A mapping rule is a rule of the form

where for all . Here, the head is a first-order formula over where denotes possible existential variables. The body of a mapping rule consists of , respectively called the negative and positive justifications and the source query . Here, and are first-order formulas over the language of , and the source query is a first-order formula over . A set of mapping rules is called a mapping program.

Example 3.

Consider a database consisting of one table Jobs_DB(<NAME>,<JOB>). Let with a unary relation of employees and two binary relations and , describing a supervising relation and a department head relation, respectively. The default rule “employees, of whom we do not know that they are the head of a department, have a supervisor” can be expressed through the following mapping:

Then a generalized OBDA specification is a triple , where is a database instance legal over a source schema , is a mapping program, and is an ontology.

Semantics

Definition 1 (Skolem program, following (?)).

Let be a mapping program. The Skolem rule associated to a rule is obtained by replacing each existential variable in by a new Skolem function symbol , where is an ordered sequence of universal variables in . Then the Skolem program of is .

A mapping interpretation is a consistent subset of , the Herbrand base over the Skolem program . Such an interpretation is said to satisfy or model a positive Skolemized mapping rule

written , if it satisfies the head or does not satisfy the body. It satisfies the body of a rule if the following holds: for every tuple , every interpretation with satisfies for all . Here, denotes the set of tuples that are answers to the query over .

Remark.

In this framework, the database query acts as a guard on the mapping rule . It is in general a first-order query. Since is interpreted solely over , mapping rules are not applicable to existential witnesses generated by mapping rule heads. In particular, the database query is a shorthand for every tuple occuring in the database.

For notational brevity, we slightly abuse notation in the following, writing instead of . Indeed, in the following we shall only consider the Skolemized mapping program.

An interpretation is said to satisfy or model a positive mapping program , written , if it satisfies all mapping rules contained in .

Example 4.

Consider the mapping from Example 3. By Skolemizing, we get the mapping program:

Definition 2 (Partial ground program, following (?)).

The partial grounding of a mapping rule is the set of all partial ground instances of over constants in for those variables that are not existential variables in the negative justifications. The partial ground program of a mapping program is the set .

Example 5.

Consider the database and mapping from Examples 3 and 4. If the set of constants occuring in the database is , then consists of the four mapping rules

for .

Definition 3 (-reduct).

Given an ontology , define the -reduct of a partial ground mapping program with respect to an interpretation as the mapping program obtained from after applying the following:

  1. Remove all mapping rules where there exists some such that .

  2. Remove all negative justifications from the remaining rules.

Example 6.

Continuing with our running example, let . Furthermore, add the mapping rules

Then for , the rules

for are removed in the -reduct construction, since . Then the -reduct w.r.t. consists of all groundings of the following rules:

A mapping interpretation is called a -answer set of if it is a -minimal model of the -reduct .

Then a tuple consisting of a first-order model and a mapping interpretation is a model of an generalized OBDA specification if

  1. ,

  2. is a -answer set of .

For a given ontology , a mapping program is said to entail a formula , written , if every -answer set of entails .

Similarly, a generalized OBDA specification entails a formula , written , if every model of entails .

Example 7.

It is easily verifiable that the set given in Example 6 is in fact a -answer set. It does not, however, entail , as the ontology axiom is not satisfied. Thus, to obtain a model of the generalized OBDA specification, any model must satisfy this axiom, in addition to the assertions in .

Remark (Extensional constraints).

Mapping programs are capable of expressing extensional constraints over the OBDA specification, i.e., constraints over the ontology language on the database and mappings. For instance, the extensional constraint , which in classical OBDA can be intuitively read as “if is contained in the ABox, then is contained in the ABox as well.” Such a constraints is expressible with the mapping , where is bottom and is the query top of appropriate arity. This guarantees that any -answer set of must satisfy this constraint. It is worth noting that, while this is similar to integrity constraints over the database, it is not entirely the same: the database schema might differ greatly from the structure of the ontology, thus allowing the possibility of describing database constraints on an ontology level.

Complexity Results

In the general case, where the heads and bodies of mapping rules are allowed to contain arbitrary first-order formulas, reasoning over mapping programs is obviously undecidable. Indeed, consider an empty and the mapping program for some arbitrary first-order formula . Then if and only if is a tautology, which is known to be undecidable for arbitrary first-order . This is summarized in the following theorem.

Theorem 1.

The problem of checking for a given mapping program and a ground atom is undecidable.

Corollary 1.

Let be a generalized OBDA specification and be a ground atom. Then is undecidable.

Now let be a pair consisting of an ontology and a set of formulas over the signature such that -entailment of any is decided by an oracle . In the following we consider mapping programs where the heads and justifications in rules contain formulas from . Then to construct a -answer set, we can employ a simple guess-and-check algorithm using the verifier given in Algorithm 1.

input ontology , partially ground Skolem program , set :
Start
      make-reduct();
     if check-sat() and check-min(then
         return true;
     end if
     return false;
End
procedure make-reduct()
     ;
     for all  do
         if  for some  then
              ;
         end if
     end for
     remove negative clauses from ;
     return ;
end procedure
procedure check-sat()
     for all  do
         if  and  then
              return false;
         end if
     end for
     return true;
end procedure
procedure check-min()
     for all  do
         if check-sat(then
              return false;
         end if
     end for
     return true;
end procedure
Algorithm 1 -answer set verifier

Correctness of Algorithm 1 is obvious: by definition, a set is a -answer set of if and only if it is a -minimal model of the -reduct . Both the construction of and the satisfiability-checking are done following the respective definitions. For -minimality, it is sufficient to check co-satisfiability of for every , since is a positive program and hence monotonic.

The complexity of Algorithm 1 depends the complexity of the oracle and the following factors. Let

  1. (resp. ) denote the number of positive (resp. negative) justifications in a mapping program , and

  2. denote the number of heads in a mapping program .

Furthermore, let denote the complexity of the oracle . Then each of the three procedures (make-reduct, check-sat, check-min) in Algorithm 1 have the following complexity:

  1. make-reduct: the oracle is called on each negative justification in , so complexity of this procedure is .

  2. check-sat: the procedure evaluates to true if, for all mapping rules , or . Thus, the oracle co- must be called on all positive justifications in . If all justifications in a rule are entailed (i.e., the co-oracle evaluates to false), the entailment of the rule heads must be checked. Hence, the complexity is bounded by .

  3. check-min: for each , co-satisfiability of must be checked. Thus, there are calls to check-sat, where the returned value is inverted.

The total complexity of Algorithm 1 is therefore the sum of the complexities of these three procedures:

Algortihm 1 is in fact a generalization of the verifier used in the guess-and-check method for classical ASP: Indeed, consider the case where and is the set of all ground atoms over the language of . In this case, the oracle must only check membership in , hence it is linear in the size of . Thus, in this setting a partially ground Skolem mapping program is simply a classical ASP program. Therefore, brave reasoning over mapping programs is at least as hard as classical ASP solving, i.e., is NP-hard (?).

More generally, for a given reasoning oracle brave reasoning over mapping programs is NP-complete.

Theorem 2.

Let be a pair consisting of an first-order ontology and a set of formulas over the language of such that -entailment is -hard for an oracle . Then for a partially ground Skolemized mapping program where the head and all justifications are formulas from , -answer set existence is NP-complete.

Proof sketch.

Intuitively, a NP Turing machine (that is, an NP Turing machine that allows for -calls on the tape) can be encoded as a mapping program in the same manner as an NP Turing machine can be encoded in classical ASP, however allowing for oracle calls in the mapping rules’ bodies. ∎

It is worth noting that, by the preceding theorem, a partially grounded Skolemized mapping program satisfying the conditions of Theorem 2 can be rewritten into an ASP program with oracle calls in the rule bodies. The resulting program, however, bears little resemblance to the original mapping program, as it is the encoding of the NP Turing machine.

UCQ-Rewritable Justifications

We now analyze a restriction of mapping programs that admit a natural reduction to classical ASP for query answering and reasoning. To this end, let be an ontology over a decidable fragment of first-order logic. We say a formula over is UCQ-rewritable with respect to if the -rewriting of is equivalent to a union of conjunctive queries (?).

Then for a mapping program where all justifications are UCQ-rewritable with respect to , let , called the -rewritten program, denote the mapping program obtained from by replacing every justification with its rewriting with respect to . The -rewritten program is equivalent to a program containing only atoms as positive justifications and CQs as negative justifications, by well-known logic program equivalence transformations (?). By abuse of notation, will in the following denote this equivalent program.

Let us first establish the connection between mapping programs and -ASP. Recall that a mapping rule can be applied to every tuple where for all positive justifications and for all negative justifications . If the TBox is empty, this statement reduces to checking whether the justifications are certain answers w.r.t. and hence simply checking containment in . This is, however, precisely the semantics of ASP with existential variables in the heads and negative bodies of rules. Hence, mapping programs can be seen as an extension of -ASP, both semantically and syntactically. This result is summarized in the following theorem.

Theorem 3.

Let be a partially ground Skolem program where all justifications are conjunctive queries. Then a set is a -answer set of iff it is a -answer set of .

The following lemma describes the relationship between -rewritten programs and reducts w.r.t. , which is particularly useful when analyzing the connection between -ASP and mapping programs, as discussed in Theorem 4.

Lemma 1.

For any the equality holds, where denotes the -rewritten program of .

Proof.

Let be a mapping rule removed from in the construction of the -reduct , i.e., there exists some such that . This is equivalent to where is the -rewriting of . Thus is removed from in the construction of the -reduct . Hence iff iff . ∎

Theorem 4.

Let be a partially ground Skolem program where all justifications are UCQ-rewritable with respect to an ontology . A set is a -answer set of iff it is an -answer set of .

Proof.

Let and let

be any rule in . We shall prove the statement by separately showing (1) the equivalence of rule satisfaction in and and (2) that is minimal iff is minimal.

  1. Satisfaction:

  2. Minimality: Assume is a model of . By 1, this is the case if and only if . Finally, Lemma 1 yields the desired result that .

As a direct consequence of the preceding theorem, the following corollary describes how query answering over an OBDA specification using a UCQ-rewritable mapping program can be reduced to query answering over an equivalent OBDA specification with an empty ontology.

Corollary 2.

Let be an OBDA specification, the -rewritten program of , a query over , and its rewriting with respect to . Then

Therefore, by Corollary 2 and Theorem 3 we find that every UCQ-rewritable mapping program is equivalent (w.r.t. answer sets) to an -ASP program. By results in (?), this can be further reduced to a classical ASP program. This is summarized in the following theorem.

Theorem 5.

For an OBDA specification , where the justifications in are UCQ-rewritable with respect to , there exists an ASP program such that for a query over

i.e., query answering over reduces to cautious reasoning over .

Conclusion and Future Work

In this paper, we propose a new mapping framework for ontology-based data access (and data transformation in general) that greatly enhances the mappings’ expressivity. Our framework allows for default reasoning over the database and ontology, as well as the expression of various epistemic properties of the database, such as extensional constraints and closed predicates. We have shown that in the case where the rule body is UCQ-rewritable, this framework can be rewritten to an equivalent -ASP program, and hence query answering reduces to cautious reasoning over ASP.

While various highly optimized ASP solvers do exist, the data complexity involved is rather undesirable in the context of real-world OBDA and big data. Therefore, one of the greatest priorities regarding future work is to determine how and when the complexity can be reduced; the mapping program should not be run on the entire data set. This could, for instance, be addressed by splitting the program into two parts, an easily solvable and a more difficult subprogram, and caching which ontology concepts are easily unfolded.

In addition to such considerations, a prototype should be implemented to demonstrate the feasibility in real contexts, and compare our framework to existing approaches.

Acknowledgments

We would like to thank the anonymous referees for their very insightful comments and suggestions.

References

  • [Alviano et al. 2011] Alviano, M.; Calimeri, F.; Faber, W.; Ianni, G.; and Leone, N. 2011. Function symbols in ASP: Overview and perspectives. In In NMR – Essays Celebrating Its 30th Anniversary, 1–24. College Publications.
  • [Antonioli et al. 2014] Antonioli, N.; Castanò, F.; Coletta, S.; Grossi, S.; Lembo, D.; Lenzerini, M.; Poggi, A.; Virardi, E.; and Castracane, P. 2014. Developing ontology-based data management for the italian public debt. In 22nd Italian Symposium on Advanced Database Systems, SEBD 2014, 353–360. Universita Reggio Calabria and Centro di Competenza (ICT-SUD).
  • [Calì, Gottlob, and Kifer 2013] Calì, A.; Gottlob, G.; and Kifer, M. 2013. Taming the infinite chase: Query answering under expressive relational constraints. J. Artif. Intell. Res. (JAIR) 48:115–174.
  • [Calì, Gottlob, and Lukasiewicz 2012] Calì, A.; Gottlob, G.; and Lukasiewicz, T. 2012. A general datalog-based framework for tractable query answering over ontologies. J. Web Sem. 14:57–83.
  • [Calvanese et al. 2007] Calvanese, D.; De Giacomo, G.; Lembo, D.; Lenzerini, M.; and Rosati, R. 2007. Tractable reasoning and efficient query answering in description logics: The DL-Lite family. J. Autom. Reasoning 39(3):385–429.
  • [Di Pinto et al. 2013] Di Pinto, F.; Lembo, D.; Lenzerini, M.; Mancini, R.; Poggi, A.; Rosati, R.; Ruzzi, M.; and Savo, D. F. 2013. Optimizing query rewriting in ontology-based data access. In Proceedings of the 16th International Conference on Extending Database Technology, EDBT ’13, 561–572. New York, NY, USA: ACM.
  • [Donini, Nardi, and Rosati 2002] Donini, F. M.; Nardi, D.; and Rosati, R. 2002. Description logics of minimal knowledge and negation as failure. ACM Trans. Comput. Logic 3(2):177–225.
  • [Eiter et al. 2008] Eiter, T.; Ianni, G.; Lukasiewicz, T.; Schindlauer, R.; and Tompits, H. 2008. Combining answer set programming with description logics for the semantic web. Artificial Intelligence 172(12–13):1495 – 1539.
  • [Garreau et al. 2015] Garreau, F.; Garcia, L.; Lefèvre, C.; and Stéphan, I. 2015. -ASP. In Proceedings of the Joint Ontology Workshops 2015 Episode 1: The Argentine Winter of Ontology co-located with the 24th International Joint Conference on Artificial Intelligence (IJCAI 2015), Buenos Aires, Argentina, July 25-27, 2015.
  • [Gebser, Kaufmann, and Schaub 2012] Gebser, M.; Kaufmann, B.; and Schaub, T. 2012. Conflict-driven answer set solving: From theory to practice. Artif. Intell. 187-188:52–89.
  • [Gelfond and Lifschitz 1988] Gelfond, M., and Lifschitz, V. 1988. The stable model semantics for logic programming. 1070–1080. MIT Press.
  • [Gomes et al. 2008] Gomes, C. P.; Kautz, H.; Sabharwal, A.; and Selman, B. 2008. Satisfiability solvers. Foundations of Artificial Intelligence 3:89–134.
  • [Hovland et al. 2015] Hovland, D.; Lanti, D.; Rezk, M.; and Xiao, G. 2015. Enabling SPARQL queries over enterprise relational data (extended version). preprint. arXiv:1605.04263v2 [cs.DB].
  • [Lembo et al. 2015] Lembo, D.; Mora, J.; Rosati, R.; Savo, D. F.; and Thorstensen, E. 2015. Mapping analysis in ontology-based data access: Algorithms and complexity. In The Semantic Web - ISWC 2015 - 14th International Semantic Web Conference, Bethlehem, PA, USA, October 11-15, 2015, Proceedings, Part I, 217–234.
  • [Lembo et al. 2016] Lembo, D.; Rosati, R.; Santarelli, V.; Savo, D. F.; and Thorstensen, E. 2016. Approaching OBDA evolution through mapping repair. In Proceedings of the 29th International Workshop on Description Logics, Cape Town, South Africa, April 22-25, 2016.
  • [Lifschitz, Tang, and Turner 1999] Lifschitz, V.; Tang, L. R.; and Turner, H. 1999. Nested expressions in logic programs. Annals of Mathematics and Artificial Intelligence 25(3):369–389.
  • [Lifschitz 2008] Lifschitz, V. 2008. What is answer set programming?
  • [Lin and Zhao 2004] Lin, F., and Zhao, Y. 2004. ASSAT: computing answer sets of a logic program by SAT solvers. Artificial Intelligence 157(1–2):115 – 137. Nonmonotonic Reasoning.
  • [Lutz, Seylan, and Wolter 2013] Lutz, C.; Seylan, I.; and Wolter, F. 2013. Ontology-based data access with closed predicates is inherently intractable (sometimes). In Proceedings of the Twenty-Third International Joint Conference on Artificial Intelligence, IJCAI ’13, 1024–1030. AAAI Press.
  • [Motik and Rosati 2010] Motik, B., and Rosati, R. 2010. Reconciling description logics and rules. J. ACM 57(5):30:1–30:62.
  • [Poggi et al. 2008] Poggi, A.; Lembo, D.; Calvanese, D.; De Giacomo, G.; Lenzerini, M.; and Rosati, R. 2008. Linking data to ontologies. Berlin, Heidelberg: Springer-Verlag. 133–173.
  • [Rosati 2012] Rosati, R. 2012. Prexto: Query rewriting under extensional constraints in dl − lite. In Simperl, E.; Cimiano, P.; Polleres, A.; Corcho, O.; and Presutti, V., eds., The Semantic Web: Research and Applications, volume 7295 of Lecture Notes in Computer Science. Springer Berlin Heidelberg. 360–374.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
11693
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description