LOGICS FOR THE

Pascal Hitzler, Jens Lehmann, Axel Polleres

Reader: Patrick Hayes

1 INTRODUCTION

A major international research effort is currently under way to improve the exist- ing (WWW), with the intention to create what is often called the Semantic Web [Berners-Lee et al., 2001; Hitzler et al., 2010]. Driven by the World Wide Web Consortium (W3C) and its director Sir Tim Berners-Lee (inven- tor of the WWW), and heavily funded by many national and international research funding agencies, Semantic Web has become an established field of research. It integrates methods and expertise from many subfields of and Artificial Intelligence [Studer, 2006], and it has now reached sufficient maturity for first industrial scale applications [Hamby, 2012; Hermann, 2010]. Correspondingly, major IT companies are starting to roll out applications involving Semantic Web technologies; these include Apple’s Siri, IBM’s Watson system, Google’s Knowedge Graph, Facebook’s Open Graph Protocol, and schema.org as a collaboration be- tween major search engine providers including Microsoft, Google, and Yahoo!. The Semantic Web field is driven by the vision to develop powerful methods and technologies for the reuse and integration of information on the Web. While current information on the Web is mainly made for human consumption, it shall in the future be made available for automated processing by intelligent systems. This vision is based on the idea of describing the meaning—or —of data on the Web using —data that describes other data—in the form of so-called ontologies [Hitzler et al., 2010]. Ontologies are essentially knowledge bases rep- resented using logic-based knowledge representation languages. This shall enable access to implicit knowledge through logical deduction [Hitzler and van Harme- len, 2010], and its use for search, integration, browsing, organization, and reuse of information. Of course, the idea of adopting knowledge representation languages raises the question which of the many approaches discussed in the literature should be adopted and promoted to Web standards (officially called W3C Recommenda- tions). In this chapter, we give an overview of the most important present stan- dards as well as their origins and history. The idea that the World Wide Web shall have capabilities to convey information for processing by intelligent systems, and not only by humans, has already been part of its original design [Berners-Lee, 1996]. The World Wide Web was initiated 2 Pascal Hitzler, Jens Lehmann, Axel Polleres in 1990, and immediately showed exponential growth [Berners-Lee, 1996]. In the meantime, it has become a very significant technological infrastructure of modern society. In the 1990s, the Semantic Web vision1 was mainly driven by the W3C Meta- data Activity [W3C Metadata, revision of 23 August 2002] which produced the first version of the Resource Description Framework (RDF) which we will discuss in Section 2. The Semantic Web Activity [W3C Semantic Web, revision of 19 June 2013] replaced the Metadata Activity in 2001, and has installed several stan- dards for representing knowledge on the Web, most noteably two revisions of RDF, the (OWL) discussed in Section 3, and the Rule Inter- change Format (RIF) discussed in Section 4. In Section 5, we discuss some of the particular challenges which must be faced when adopting logic-based knowledge representation languages for the Semantic Web, and in Section 6 we discuss some of the more recent research developments and questions. Note that we give a more detailed technical account for RDF than for OWL and RIF, because the latter are closely related to description logics and logic programming, respectively, and the reader is refered to the corresponding chapters in this volume for additional background and introductions.

2 RDF AND RDF SCHEMA

The Resource Description Framework (RDF) [Manola et al., 2004; Hayes, 2004] comprises a simple data format as well as a basic schema language, called RDF Schema [Brickley and Guha, 2004]. While historically often termed a “medadata” standard, that is, an exchange format for data about documents and resources, in the meantime, RDF has been well established as a universal data exchange format for classical data integration scenarios, and particularly for publishing and exchanging structured data on the Web [Polleres et al., 2011]. Informally, all RDF data can be understood as a set of subject–predicate–object triples, where all subjects and predicates are Uniform Resource Identifiers (URIs)2 [Berners-Lee et al., 2005], and in the object position both URIs and literal values (such as numbers, strings, etc.) are allowed. Such a simple, triple based format was chosen since on the one hand, it can accomodate for any kind of metadata in the form of predicate-value pairs, and on the other hand, any more complex relational or object-oriented data can be decomposed into such triples in a fairly straightforward manner [Berners-Lee, 2006].3 Last, but not least, since URIs are being used as constant symbols in the lan- guage of RDF, any RDF triple may likewise be viewed as a generalization of

1The term Semantic Web became popular in the aftermath of the widely cited popular science article [Berners-Lee et al., 2001]. We were able to trace the term Semantic, in relation to Web, back to a 1994 presentation by Tim Berners-Lee [Berners-Lee, 1994]. 2URIs are a generalization of URLs. 3See also the discussion of semantic networks in the chapter on description logics, in this volume. Logics for the Semantic Web 3

http://www.w3.org

dc:creator

Figure 1. An RDF triple

a “link” on the Web; as opposed to plain links on the traditional Web, on the Semantic Web, links can be associated with an arbitrary binary relation, which again is represented by a URI. We note that this idea of “typed” links was already part of Tim-Berners Lee’s original design ideas of the Web [Berners-Lee, 1993; Berners-Lee and Fischetti, 1999]. For instance, on the website of the W3C (http: //www.w3.org, if one wants to state that the page with the URI http://www.w3. org/DesignIssues/TimBook-old/History.html was created by Tim Berners- Lee, this fact may be viewed as such a typed link, and consequently as an RDF subject-predicate-object triple, as shown in Fig. 1. Here, the URI dc:creator is used to denote the has-creator relation between a resource and its creator. This common view of typed links as labeled edges linking between resources also leads to sets of RDF triples often being called “RDF graphs.”

A distinguished relation within RDF, represented by the URI rdf:type is the is-a relation, that allows to denote membership to a certain class, where classes are again represented by URIs, for instance the class :Person. Another important feature of RDF is that so called “blank nodes” can be used in the subject or object positions of triples to denote unnamed or unknown resources. This allows to model incomplete information in the form of existentials. For instance, the RDF graph in Fig. 2 extends the information in Fig. 1 by the fact that Tim Berners-Lee is a Person, is named “Timothy Berners-Lee” and knows some person named “Dan Brickley”.

In the following, after giving a brief history of the RDF standard (Section 2.1), we will present the RDF Data model along with a short discussion of different syntactic representations and the semantics of RDF (Section 2.2). We continue with a discussion of RDF Schema in Section 2.3 and the query language SPARQL in Section 2.4. 4 Pascal Hitzler, Jens Lehmann, Axel Polleres

http://www.w3.org

dc:creator

foaf:name rdf:type foaf:knows foaf:Person

“Timothy Berners-Lee” rdf:type

foaf:name

“Dan Brickley”

Figure 2. An RDF graph with a “blank” (anonymous) node

2.1 Brief History of RDF The standardisation of RDF has been preceded by two earlier proposals for meta- data standards in the form of W3C member submissions, namely (i) the Chan- nel Definition Format [Ellerman, 1997] and (ii) the Meta Content Framework (MCF) [Guha and Bray, 1997]. While the former comprised an XML format with a fixed term of metadata properties for describing information channels on the Web, (somewhat similar to RSS nowadays), the latter (MCF) was strictly extensible and evolved into the first version of RDF [Lassila and Swick, 1999], published in 1999. Another important metadata initiative from the digital libraries community, [Nilsson et al., 2008], which started around the same time but outside of W3C, later on adopted RDF as a representation syntax, becoming one of the most prominent RDF vocabularies, see Section 2.3 below. The first official standard recommendation of RDF from 1999 was extended in 2004 by a formal definition of the Semantics of RDF [Hayes, 2004], decoupling the syntactical representation in XML from the RDF data model. Since then RDF has been used in various contexts and experienced wide adop- tion. In 2009 the W3C held a workshop on future directions of RDF [Herman, 2009], discussing several extensions but also simplifications of the standard. These extensions are currently under discussion in the ongoing W3C RDF 1.1 working group.4

4See http://www.w3.org/2011/rdf-wg/. Logics for the Semantic Web 5

2.2 Different Syntactic Representations and Semantics

There are various serialisations for RDF. Fig. 3 shows different syntactic represen- tations of the six triples in the RDF graph from Fig. 2 in some of these serialisation syntaxes: N-Triples [Beckett and McBride, 2004a], cf. Fig. 3(a) is a simple line- based format that serializes one RDF triple per line terminating each line triple with a full-stop ‘.’, enclosing URIs in angle brackets, and literals in quotes; blank nodes are given alphanumeric identifiers (also called blank node label, preceded by by the prefix ‘ :’. [Beckett and Berners-Lee, 2011], shown in Fig. 3(b) ex- tends the simple N-Triples format by shortcuts making the language more legible, such as namespace prefix and base URI declarations, similar to XML, for abbrevi- ating URIs, as well as the possiblity to separate predicate-object groups for triples with the same subject by semicolon, etc. The original RDF/XML [Beckett and McBride, 2004b] syntax was an XML format, that encoded predicates as XML elements, with some abbreviations, such as rdf:type triples that refer to class membership of a node can be also directly encoded as XML elements, an example of which is given in Fig. 3(c). Other serialization syntaxes for RDF, which do not detail herein, include the RDFa [Herman et al., 2013], which provides means to syntactically embed RDF directly as markup into (X)HTML documents. We note that RDFa is particularly similar – and in fact intertranslatable – to other metadata markup formats in HTML such as the increasingly popular format [Hickson, 2012] (which is actively promoted by schema.org). The fundamental difference between RDF and general XML is that the intuition of the RDF data model is that the syntactic representation, and also the order of triples is irrelevant, which intuitively implies a notion of equivalence between RDF graphs that is independent of the serialization. While this RDF data model was not formally described in the 1999 version of RDF [Lassila and Swick, 1999], formal definitions were introduced in the specification of 2004, where a formal model-theoretic semantics was defined [Hayes, 2004], and later refined in the recent RDF1.1 specification [Hayes and Patel-Schneider, 2014]. For the exposition of this formal semantics in this chapter, we will stick with a notation similar to the one introduced in [Guti´errez et al., 2004] rather than quoting the original W3C specification verbatim. DEFINITION 1. The set of RDF terms U ∪ L ∪ B consists of elements from three infinite disjoint sets U (RDF URI references), L (RDF Literals), and B = {bj : j ∈ N} (RDF blank nodes). Note that for the exposition herein we restrict literals to plain string literals, in general RDF also offers language tagged literals, as well as so called “typed” literals, that is, pairs (l, d) where l ∈ L is a string, and d is either a string lan- guage tag [Phillips and Davis, 2006], or, respectively, d ∈ D is a URI represent- ing a datatype (such as e.g. http://www.w3.org/2001/XMLSchema#decimal), see also [Biron and Malhotra, 2004]. 6 Pascal Hitzler, Jens Lehmann, Axel Polleres

. "Timothy Berners-Lee" . . _:b1 . _:b1 "Dan Brickley" . _:b1 .

(a)

@base . @prefix dc: . @prefix foaf: . @prefix rdf: . @prefix rdfs: .

dc:creator . foaf:name "Timothy Berners-Lee"; rdf:type foaf:Person ; foaf:knows [ foaf:name "Dan Brickley" ; rdf:type foaf:Person ] . (b)

Timothy Berners-Lee Dan Brickley

(c)

Figure 3. An RDF Graph in N-Triples, Turtle, and RDF/XML syntax Logics for the Semantic Web 7

∃x triple(history.html, creator, card#i)∧ triple(card#i, name, "Timothy Berners-Lee"∧ triple(card#i, type, Person)∧ triple(card#i, knows, x)∧ triple(x, name, "Dan Brickley"∧ triple(x, type, Person)

(a)

∃x creator(history.html, card#i)∧ name(card#i, "Timothy Berners-Lee"∧ Person(card#i)∧ knows(card#i, x)∧ name(x, "Dan Brickley"∧ Person(x)

(b)

∃x history.html[creator → card#i]∧ card#i[name → "Timothy Berners-Lee"]∧ card#i : Person∧ card#i[knows → x]∧ x[name → "Dan Brickley"]∧ x : Person

(c)

Figure 4. The RDF Graph from Fig. 2 in first-order logic using ternary encoding with an auxiliary predicate triple, unary/binary encoding, and F-Logic-style frames. 8 Pascal Hitzler, Jens Lehmann, Axel Polleres

DEFINITION 2. A triple (s, p, o) ∈ (U ∪ B) × U × (U ∪ B ∪ L) is called an RDF triple, where s is called the subject, p the predicate and o the object. An RDF graph (or, just graph) is a set of RDF triples. A (proper) subgraph is a (proper) subset of a graph. The universe of a graph G, universe(G), is the set of elements of U ∪ B ∪ L that occur in the triples of G. The vocabulary VG of a graph G is the set universe(G) ∩ (U ∪ L). Finally a triple, or graph, respectively, is called ground, if it does not contain any blank nodes. The intention of blank nodes in RDF suggests that graphs that only differ in the identifiers used for blank nodes in a concrete syntactical representation should be considered equivalent. Likewise, a graph G1 that can be turned into a subgraph G2 of by just renaming blank nodes in G1 to RDF terms from the universe of G2, does not carry more information than G2 and should thus be considered “entailed” by G2. This intention is reflected in the formal model-theoretic semantics of RDF that is – in principle – based on the usual idea of first-order interpretations, with the caveat that elements of U both reflect binary relations and constants at the same time. This leads to a somewhat non-standard definition of interpretations in RDF. DEFINITION 3. (from [Hayes, 2004, Section 1], slightly simplified.5)A simple EXT T erms RDF interpreretation I = h∆, ∆p,I ,I ,LV i over an RDF vocabulary V consists of

• a non-empty domain ∆, i.e. the set of resources, which contains the set LV = L ∩ V .

• a non-empty set of properties ∆P , not necessariliy disjoint with ∆

• a function IEXT : ∆P → ∆ × ∆, which maps properties to binary relations

UL UL • a function I : UV ∪ LV → ∆, where I (l) = l for l ∈ LV (that is, literals are interpreted as themselves)

Finally, satisfaction of an RDF triple, or graph, respectively, under an interpre- tation I is defined as follows. DEFINITION 4. An interpretation I satisfies a ground triple triple t = (s, p, o), written I |= t if s, p, o ∈ V , IT erms(p) ∈ ∆P and (IT erms(s),IT erms(o)) ∈ IEXT (IT erms(p)). Accordingly, a ground RDF graph G is satisfied under I, writ- ten I |= G if and only if I |= t for all t ∈ G. Finally, a non ground graph G0 is satisfied under I if there exists an extension [IUL + A] of IUL by an assignment A : B → ∆, such that

([IT erms + A](s), [IT erms + A](o)) ∈ IEXT (IT erms(p))

5As mentioned above, as opposed to [Hayes, 2004] we do not consider typed literals nor language tagged literals here, but only plain string literals. Logics for the Semantic Web 9 for all t ∈ G. We note that when looking at Definition 4 that the semantics of blank nodes corresponds exactly to that of existential variables in first-order logic. Simple entailment between (sets of) RDF graphs is then defined following usual terminology. DEFINITION 5. Given a set S of RDF graphs (simply) entails a graph G, written S |= G, if every interpretation which satisfies every member of S also satisfies G. Given the intention outlined above, entailment should also be expressible in terms of blank node mappings. DEFINITION 6. Here, A map is a function µ : U ∪ B ∪ L → UBL preserving URIs and literals, i.e., µ(u) = u and µ(l) = l for all u ∈ U and l ∈ L. Using such maps, indeed the notion of entailment between two RDF graphs can be defined via the so-called interpolation lemma from [Hayes, 2004, Section 2], rather than in a model-theoretic way.

LEMMA 7 Interpolation Lemma. Let G1, G2 be RDF graphs, then G1 |= G2 if a subgraph of G1 is an instance of G2, that is, if there exists a map µ, such that µ(G2) is a subgraph of G1.

Given G1, G2, deciding whether there exists such a map, boils down to graph homomorphism, which is well known to be an NP-complete problem [Garey and Johnson, 1979], and therefore also NP-completeness of simple RDF entailment follows. Fragments of RDF where entailment is tractable include obviously ground graphs, but also graphs where blank nodes are not used in a cyclic fashion across triples [Pichler et al., 2008] Obviously, due to this existential semantics of blank nodes there could be inner redundancy in an RDF graph, that is, if there is a homomorphism of G to itself. This redundancy is called non-leanness in RDF terminology. DEFINITION 8. A graph G is lean if there is no map µ such that µ(G) is a proper subgraph of G. Unfortunately, as a consequence of the NP-completeness of simple entailment, deciding leanness is also intractable, namely coNP-complete [Guti´errez et al., 2004]. As a side note, let us note that it has often been critizized by practitioners that the existential treatment of blank nodes, which leads to this high complexity, puts an unnecessary burden on RDF users and implementers, and moreover is not consistently followed in neighbouring standards that build on top of RDF [Mallea et al., 2011].

Relation of RDF to other Logical Formalisms Another way to show NP-completeness of RDF simple entailment is that RDF entailment can straightforwardly be encoded into entailment of first-order-logic 10 Pascal Hitzler, Jens Lehmann, Axel Polleres formulae with existentials and conjunction only, which is well known to be just another formulation of conjunctive query containment [Chandra and Merlin, 1977], as shown in the following theorem, which is implicit in [de Bruijn and Heymans, 2007].

THEOREM 9. Given RDF graphs G1 and G2, we have that G1 |= G2 if and only if T (G1) |=FOL T (G2) where a first order theory T (G) is obtained from a graph G as follows ^ T (G) = ∃x∈VG∩Bx triple(s, p, o) (s,p,o)∈G

An example for this encoding into first-order logic is shown in Fig.4(a); Another common way to encode RDF into first-order logic is using unary predicates for triples modeling an is-a relationship, i.e. rdf:type triples, and binary predicates for all other properties, cf. Fig. 4(b). We note though that this representation is of somewhat limited use to encode arbitrary RDF graphs, since for instance blank nodes in the object positions of rdf:type triples, which is perfectly fine in the general setting of RDF, would result in a second-order formula. Note that, translation to a first-order setting in [de Bruijn and Heymans, 2007] uses F-Logic [Kifer et al., 1995] instead of classical first-order logic, which may be considered as syntactic sugar; a respective encoding of RDF triples in F-Logic frame syntax is shown in 4(c).

2.3 RDF Schema (RDFS) The generic semantics defined by simple RDF interpretations is restricted to inter- pretations that give a special meaning to the RDF and RDFS vocabulary, that is, for URIs in the rdf: (http://www.w3.org/1999/02/22-rdf-syntax-ns#) and rdfs: (http://www.w3.org/2000/01/rdf-schema#) namespaces, cf. the respec- tive prefix declarations in Fig 3(b) for the full URIs. This special semantics allows to express simple ontologies, in the form of (i) defining subclass and subproperty hierarchies, and (ii) defining domain and range restrictions of properties. The RDFS semtantics restricts interpretations as per Def. 3 above such that (i) a set of axiomatic triples, cf. [Hayes, 2004, Sections 3.1 and 4.1] are true in any RDFS interpretation, and (ii) a set of entailment rules holds, that affect how rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain, rdfs:range, etc. triples are interpreted. Figure 5 shows some of the RDFS axiomatic triples. Further, with the encoding of RDF Graphs into first-order logic from Fig. 4(a) in mind, the RDFS entailment rules can to a large extent be approximated by the first-order rules shown in Table 1 (from [Eiter et al., 2008b]). The fact that these rules are simple Horn rules and that RDF is encodable as a set of facts makes reasoning in RDFS thus amenable to simple (Datalog) rule engines. Mu˜nozet al. [Mu˜noz et al., 2007] have argued for a simpler set of entailment rules that leaves out inferences that might be considered redundant for many applications of RDF and RDFS, for instance leaving out axiomatic triples or rules like the first seven rules in Table 1. Logics for the Semantic Web 11

rdf:type rdf:type rdf:Property . rdf:type rdfs:domain rdfs:Resource . rdfs:domain rdfs:domain rdf:Property . rdfs:range rdfs:domain rdf:Property . rdfs:subPropertyOf rdfs:domain rdf:Property . ...

Figure 5. Some of the axiomatic triples that are true under the RDFS semantics.

Table 1. RDFS entailment rules, written as first-order Horn rules

∀S, P, O (triple(S, P, O) ⊃ triple(S, rdf:type, rdfs:Resource)) ∀S, P, O (triple(S, P, O) ⊃ triple(P, rdf:type, rdf:Property)) ∀S, P, O (triple(S, P, O) ⊃ triple(O, rdf:type, rdfs:Resource)) ∀C (triple(C, rdf:type, rdfs:Class) ⊃ triple(C, rdfs:subClassOf, rdfs:Resource)) ∀S, C (triple(S, rdf:type,C) ⊃ triple(C, rdf:type, rdfs:Class)) ∀C (triple(C, rdf:type, rdfs:Class) ⊃ triple(C, rdfs:subClassOf,C)) ∀P (triple(P, rdf:type, rdf:Property) ⊃ triple(P, rdfs:subPropertyOf,P )) ∀S, P, O (triple(S, P, O) ∧ triple(P, rdfs:domain,C) ⊃ triple(S, rdf:type,C)) ∀S, P, O, C (triple(S, P, O) ∧ triple(P, rdfs:range,C) ⊃ triple(O, rdf:type,C))

∀C1,C2,C3 (triple(C1, rdfs:subClassOf,C2) ∧

triple(C2, rdfs:subClassOf,C3) ⊃ triple(C1, rdfs:subClassOf,C3))

∀S, C1,C2 (triple(S, rdf:type,C1) ∧ triple(C1, rdfs:subClassOf,C2) ⊃ triple(S, rdf:type,C2))

∀P1,P2,P3 (triple(P1, rdfs:subPropertyOf,P2) ∧

triple(P2, rdfs:subPropertyOf,P3) ⊃ triple(P1, rdfs:subPropertyOf,P3))

∀S, P1,P2,O (triple(S, P1,O) ∧ triple(P1, rdfs:subPropertyOf,P2) ⊃ triple(S, P2,O))

By giving a special semantics to the rdfs: vocabulary, RDF Schema enables the meta-description of other RDF vocabularies with the goal that additional triples will be entailed under the RDFS semantics. As such RDFS can be consid- ered a simple ontology language, that is used within popular Web ontologies such as the Friend-of-a-friend (foaf:) or the Dublin Core (dc:) vocabulary descrip- tions [Brickley and Miller, 2007; Nilsson et al., 2008]. Fig. 6 shows a snippet of the FOAF ontology, along with some additional triples that can be derived from this RDFS ontology together with the RDF graph from Fig. 3.

Relation of RDFS to other Logical Formalisms A mapping from RDF interpretations to first-order logics is given in [Franconi et al., 2005]. This picture is completed in [de Bruijn and Heymans, 2007], em- bedding RDF(S) within the framework of F-Logic [Kifer et al., 1995], and also covering the extensional semantics of RDFS [Hayes, 2004, Section 4.2]; addi- tional considerations regarding special semantics of datatype literals (cf. [Hayes, 12 Pascal Hitzler, Jens Lehmann, Axel Polleres

foaf:Person rdfs:subClassOf foaf:Agent . foaf:knows rdfs:domain foaf:Person . foaf:knows rdfs:range foaf:Person . foaf:name rdfs:subPropertyOf rdfs:label . ...

(a)

rdf:type foaf:Agent . rdfs:label "Timothy Berners-Lee" . _:b1 rdf:type foaf:Agent . _:b1 rdfs:label "Dan Brickley" .

(b)

Figure 6. (a) Some RDFS statements from the FOAF vocabulary description, plus (b) some additional triples inferrable from these statements together with the RDF graph from Fig. 3

2004, Section 5]) are covered in [de Bruijn and Heymans, 2010]. Another re- cent paper by Franconi et al. [Franconi et al., 2013] discusses the logic of the extensional RDF semantics, which is only a non-normative part of the RDF spec- ification, in more detail; remarkably, the authors come to the conclusion that the extensional RDFS semantics can likewise be implemented by a set of infer- ence rules, where the closure is computable in polynomial time in a forward- chaining manner, thus contradicting the conjecture in the original RDF spec- ification that the extensional semantics would “require more complex inference rules” [Hayes, 2004, Section 4.2] The core semantics of RDFS, that is reasoning about rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain, and rdfs:range has also been associated in the literature with a minimalistic fragment of the Description Locigs family DL-Lite [Calvanese et al., 2007; Poggi et al., 2008; Franconi et al., 2013]; a respective mapping from RDFS stratements to DL-Lite is shown in Table 2. We note though that only restricted RDF graphs, that do not use the RDF and RDFS vocabulary in a “non-standard” [de Bruijn and Heymans, 2007] fashion (e.g., using rdfs:subclass in an object position, or – as already mentioned above – blank nodes in the object position of rdf:type triples) are amenable to such en embedding into DL-Lite.

2.4 SPARQL In order to facilitate queries over RDF and RDFS, the W3C has defined a standard query language, SPARQL [Harris and Seaborne, 2013], which at its core facilitates conjunctive queries over RDF graphs. Such conjunctive queries are called Basic Graph Patterns (BGPs) in SPARQL and syntactically expressed as RDF graphs with (‘?’-prefixed) variables allowed in subject, predicate or object positions of Logics for the Semantic Web 13

Table 2. DL-Lite axioms vs. RDF(S) DL-Lite RDFS A1 v A2 A1 rdfs:subClassOf A2. ∃P v AP rdfs:domain A. ∃P − v AP rdfs:range A. P1 v P2 P1 rdfs:subPropertyOf P2. A(x) x rdf:type A. P (x, y) x P y.

SELECT ?X WHERE { ?X rdf:type foaf:Person . ?X foaf:knows ?Y . ?Y foaf:name "Dan Brickley" }

answer(x) → triple(x, type, P erson) ∧ triple(x, knows, y) ∧ triple(y, name,00 Dan Brickley00)

Figure 7. A simple SPARQL query asking for persons who know someone named “Dan Brickley” and its corresponding conjunctive query in first-order syntax triples to facilitate joins and projection (using the keyword ’SELECT’). Figure 7 shows a simple SPARQL query and its corresponding transcription into a conjunc- tive query. SPARQL allows more complex patterns on top of BGPs, such as unions of patterns, optional query patterns and filters, where the expressivity of the SPARQL in its version 1.0 [Prud’hommeaux, 2008] language was shown to cap- ture Relational Algebra, or non-recursive Datalog with negation, respectively, by Angles and Gutierrez [Angles and Gutierrez, 2008]. We note that the recent SPARQL 1.1 [Harris and Seaborne, 2013] specification has additional expressivity e.g. by allowing aggregates plus a basic form of regu- lar path queries, which can no longer be captured in non-recursive Datalog with negation alone [Polleres and Wallner, 2013]. Moreover, SPARQL in its version 1.0 was solely defined in terms of RDF simple entailment, SPARQL 1.1 defines which additional answers a SPARQL query should return under RDFS and OWL semantics (see Section 3 below).

3 DAML/OIL AND OWL

3.1 A Brief History While the previously described RDF and RDFS languages already allow to model domain knowledge, they are not very expressive and often insufficient for capturing the necessary relationships and constraints. Therefore, the development of richer representations was an early goal in the Semantic Web initiative, which eventually 14 Pascal Hitzler, Jens Lehmann, Axel Polleres led to the OWL ontology language. One of the main predecessors of OWL are frame based systems. While the no- tion of frames was previously introducted in different contexts, e.g. [Minsky, 1975], a major development were the structured inheritance networks developed at the end of the 70s in [Brachman, 1978]. In those systems, the core modelling struc- tures are frames – now more commonly referred to as classes in object oriented programming languages and ontology languages. Frames usually had specific at- tributes (also called properties) describing them. This differs from the previously described RDFS language and OWL itself in which properties are autonomous entities. Using domain and range axioms, RDFS properties can be used to model frame-like structures. Another consequence of properties being autonomous enti- ties, is that their usage in RDFS and OWL is not restricted to instances of a single class/frame. While early frame based systems lacked formal semantics, this deficit was over- come by the introduction of description logics (DLs). The first DL-based KR system is KL-ONE [Brachman and Schmolze, 1985]. We refrain from describing those in detail as they are already covered in the chapter on description logics in this volume. In contrast to some frame-based systems, DLs have a clear focus on logic based semantics and reasoning, which are now considered essential for an ontology language [Baader, 2003]. DLs later became the formal foundation of the OWL ontology language and enjoy an increase in popularity and usage. OWL and the underlying DLs go far beyond early frame based systems and RDF, e.g. it supports specific characteristics like functionality and transitivity for properties as well as complex class expressions. A major turning point after the gradual introduction of some key technologies like frames and description logics more than 30 years ago was the rise of the World Wide Web in the 90s. Web technologies, e.g. XML, had a major influence on OWL. After the introduction of a first RDF recommendation in 1999, standardisation efforts on the introduction of an ontological layer in the Semantic Web intensified while a new version of RDF was developed in parallel. Ultimately, this resulted in the Web Ontology Language OWL becoming an official W3C recommendation in 2004, which was published together with the revised RDF W3C recommendation. The predecessors of OWL are DAML, OIL and to a lesser extent SHOE. SHOE6 is an extension of HTML, which was developed around 1996 and makes it possible to annotate web documents with machine-readable information. While the project is no longer active, it influenced the development of the DAML+OIL language. DAML (DARPA Agent Markup Language) was a funding program in the US, which started in 1999 and involved and Tim Bernes-Lee. The program pursued the development of machine readable knowledge representation languages for the web. A main result of the DAML program was the DAML language, which was already based on RDF. In parallel to the development of DAML, the aim of OIL (Ontology Inference Layer) was to provide an infrastructure for the Semantic Web [Fensel et al., 2001]. The authors of [Fensel et al., 2001]

6http://www.cs.umd.edu/projects/plus/SHOE/ Logics for the Semantic Web 15 state that RDFS served as starting point for OIL and they developed it into a ”full-fledged Web-based ontology language” including formal semantics. OIL development started at the end of the 90s. Finally, in December 2000 the first version of the language DAML+OIL [McGuinness et al., 2002] was released. While using DAML as a foundation, this language focused on the inclusion of the clear semantics underlying OIL. It also used the expressive power of OIL, specifically the SHIQ [Horrocks et al., 2003]. DAML+OIL was subsequently used as starting point for the W3C Web Ontology Working Group. In 2004, this working group produced the W3C recommendation OWL – Web Ontology Language [Web Ontology Working Group, 10 February 2004]. Since then OWL served as a backbone for knowledge representation on the web and several inference algorithms for it, in particular for OWL DL, were developed and implemented. As the people involved in the development of DAML, OIL and OWL often had different technological backgrounds, ideas and expertise than those working on the RDF specifications, joining those two strands was a tense and difficult process. This is one of the reasons why different OWL dialects were created with varying compatibility with RDF. In 2009, after several years of refinements, OWL 2 became a W3C recommen- dation [OWL Working Group, 27 October 2009] (note that the 2012 version of the recommendation document [Hitzler et al., 2012] contains only very minor changes, most of them editorial). OWL 2 was started as an incremental improvement of OWL, but during the development of the language, it turned out that in sum the required changes and addressed deficiencies are substantial: ”None of these problems are severe, but, taken together, they indicate a need for a revision of OWL 1” [Grau et al., 2008]. From a knowledge representation perspective, OWL 2 mainly builds on SROIQ(D), whereas OWL 1 mainly used SHOIN (D) – see the description logic chapter in this volume for details.

3.2 Quick Introduction to OWL Based on the introduction of description logics in the corresponding chapter in this volume, we will now describe the Web Ontology Language OWL. For brevity, we focus on the OWL DL dialect. In essence, OWL DL is based on description logics extended by several features to make it suitable as a web ontology language, e.g. using URIs/IRIs as identifiers, imports of other ontologies and annotations of URIs and axioms. By basing OWL DL on description logics, it can make use of the theory developed for DLs, in particular sophisticated reasoning algorithms. In OWL, different naming conventions are usually used compared to description logics. OWL classes correspond to concepts in description logics and properties correspond to roles. While being based on description logics, OWL is also seen as a language ex- tending RDF in the Semantic Web layer cake. However, the semantics of RDF differs from that of description logics and does in general not necessarily lead to the same logical consequences. Due to being based on RDF and DLs, there are 16 Pascal Hitzler, Jens Lehmann, Axel Polleres

OWL expression / OWL 2 DL syntax Manchester syntax axiom Thing > Thing Nothing ⊥ Nothing intersectionOf C1 u ... u Cn C1 and ... and Cn unionOf C1 t ... t Cn C1 or ... or Cn complementOf ¬C not C oneOf {x1} t ... t {xn} {x1, . . . , xn} allValuesFrom ∀r.C r only C someValuesFrom ∃r.C r some C maxCardinality (X) ≤ n r C r max n minCardinality (X) ≥ n r C r min n cardinality (X) ≤ n r C u ≥ n r C r exact n C hasSelf X ∃s.Self r Self subClassOf C1 v C2 C1 SubClassOf: C2 equivalentClass C1 ≡ C2 C1 EquivalentTo: C2 disjointWith C1 ≡ ¬C2 C1 DisjointWith: C2 sameAs {x1} ≡ {x2} x1 SameAs: x2 differentFrom {x1} v ¬{x2} x1 DifferentFrom: x2 domain ∀r.> v C r Domain: C range > v ∀r.C r Range: C subPropertyOf r1 v r2 r1 SubPropertyOf: r2 equivalentProperty r1 ≡ r2 r1 EquivalentTo: r2 − inverseOf r1 ≡ r2 r1 InverseOf: r2 TransitiveProperty r+ v r r Characteristics: Transitive FunctionalProperty > v ≤ 1 r r Characteristics: Functional ReflexiveProperty X Ref(r) r Characteristics: Reflexive propertyChainAxiom X r1 ◦ ... ◦ rn v s s SubPropertyChain: r1 o . . . o rn

Table 3. OWL constructs in DL and Manchester OWL syntax (excerpt). X indicates that the construct is only available in OWL 2 and (X) indicates that it was extended in OWL 2. two different definitions of formal semantics: Direct Semantics, which are based on DLs, and RDF-based Semantics. In general, OWL offers more convenience constructs than the corresponding de- scription logics, but does not extend its expressivity. For instance, the domain and range constructs inherited from RDF are logically redundant, i.e. can be expressed using other constructs, but are part of the language, since they simplify modelling for knowledge engineers. It should be noted that OWL does not make the unique name assumption, so different individuals can be mapped to the same domain element. It allows us to express equality and inequality between individuals (a = b, a 6= b) using owl:sameAs and owl:differentFrom. Most algorithms for description logics al- ready supported this distinction before the OWL specification was created. Not Logics for the Semantic Web 17 making the unique names assumption is crucial in the Semantic Web, where it is often the case that many knowledge bases contain information about the same entity. In this case, a common approach is that each uses their own URI namespace and owl:sameAs is used to connect individuals. Table 3 shows, for some examples, how constructs in OWL can be mapped to description logics. We can see that some features can be mapped directly to description logics, e.g. union, and others are syntactic sugar, e.g. functional properties. OWL has different syntactic formats, in which a knowledge base can be stored. Since it can be converted to RDF, formats like RDF/XML or Turtle can be used. There is also a special XML syntax called OWL/XML as well as the Manchester OWL Syntax. For details on Manchester OWL syntax (e.g. used in the Prot´eg´eeditor) see [Horridge and Patel-Schneider, 2008] and the OWL 2 Manchester Syntax Specification [OWL Working Group, 11 December 2012]. The latter is popular in ontology editors. However, the RDF-based syntax plays a special role since its support is required for tools to be compliant with the OWL standard. Examples for Manchester OWL Syntax are shown on the right column in Table 3. Note that OWL 2 also supports the creation of datatypes as discussed in detail in [Motik and Horrocks, 2008], but a discussion of them is omitted for brevity in this section.

3.3 Relations to other Formalisms OWL 1 comes in three flavors: OWL Lite, OWL DL, and OWL Full. For OWL 1, OWL Lite corresponds to the description logic SHIF(D) and OWL DL to the description logic SHOIN (D). OWL Full contains features not expressible in description logics, but needed to be compatible with RDFS. In this sense, OWL Full can be seen as the union of RDFS and OWL DL in terms of language features or, alternatively, as OWL without syntactic restrictions. The latest version OWL 2 is again split in two flavors OWL 2 DL and OWL 2 Full. OWL 2 DL corresponds roughly to the logic SROIQ(D). An exception for this are the so called keys, which essentially state that certain property values and class memberships are sufficient to uniquely identify an individual. This language feature is derived from relational technology and cannot be expressed in DLs. A further interesting feature of OWL 2 DL is meta-modelling via punning, which allows to use the same URI for an entity denoting a class and an individual. Internally, those are then semantically treated as separate entities. As in OWL, there is also an OWL 2 Full variant introduced for RDFS com- patibility. In addition, three profiles were introduced: EL, QL, and RL. Each profile imposes, usually syntactical, restrictions on OWL in order to allow for more efficient reasoning. OWL 2 EL is aimed at applications which require ex- pressive property modelling and is based on the logic EL++, which guarantees polynomial reasoning time wrt. ontology size for all standard inference problems. QL is targeted at applications with massive volumes of instance data. In QL, query answering can be implemented on top of conventional relational database 18 Pascal Hitzler, Jens Lehmann, Axel Polleres systems and sound and complete conjunctive query answering methods can be im- plemented in LOGSPACE. As in the EL profile, the standard inference problems run in polynomial time. RL is aimed at scalable applications, which however, do not want to sacrifice too much expressive power. Reasoning algorithms for it can be implemented in rule-based engines and run in polynomial time. The EL and QL languages are subsets of OWL 2 DL, whereas RL provides two variants where one is subset of OWL 2 Full and the other one is a subset of OWL 2 DL. Compared to RDFS, OWL Full is much more expressive by allowing the con- struction of complex concepts via boolean connectors (conjunctions, disjunction, negation) as well as cardinality restrictions (minimum, maximum and exact car- dinality). Furthermore, it includes several other features such as class disjointness and more fine-granular property modelling. Properties can be declared to be re- flexive, functional, symmetric or equivalent to other properties. Due to those characteristics, OWL is usually seen as a full-fledged ontology language, whereas RDFS is more suitable for lightweight vocabularies. However, while RDFS allows reification as a method for adding contextual information (see discussion below in Section 6), this is not allowed in OWL DL and generally not supported in standard description logics. More details on the OWL language and its formal foundations can be found in the [Hitzler et al., 2010]. For technical details, we refer to the W3C recom- mendations, in particular those for OWL 2 [OWL Working Group, 27 October 2009].

4 RULES

Rules come in many guises. In one of their most basic forms, they consist of statements of the form ^ Ai → B, i where B (the head of the rule) and all Ai (which form the body of the rule) are atomic formulas from first-order predicate logic, and all variables in the rule are considered universally quantified.7 Function symbols may or may not be allowed. Additional logical connectives may be allowed, e.g. disjunctions or existential quan- tifiers in the rule head. Constructs from other, e.g. modal or non-monotonic, logics may be allowed. Atomic formulas in head or body may be replaced by procedural built-ins or other executable commands. If a formal semantics is defined for a rules language, it may range from a full first-order predicate logic semantics to an entirely procedural specification. Logic programming, as discussed in the chapter by Robert Kowalski in this volume, is one rather prominent example of such a rules language. Many rules paradigms had already been well established in research and in- dustry, when the World Wide Web Consortium set out to define a recommended

7The universal quantifier is usually omitted. Logics for the Semantic Web 19 standard for modeling ontologies for the Semantic Web. Rules, in particular in the broad sense of logic programming, were a very strong contender for the base paradigms on which to base this recommended standard. As discussed in Sec- tion 3, description logics were eventually chosen, but a significant research and industrial interest remained in giving rules a more prominent role, and in the af- termath of the 2004 W3C OWL specification [Web Ontology Working Group, 10 February 2004], the ensuing discussions on the role of rules for the Semantic Web were sometimes rather fierce [Horrocks et al., 2005a; Kifer et al., 2005]. One of the prominently discussed paradigms was F-Logic [Kifer et al., 1995], in its variant as a primarily syntactic extension of logic programming [Angele and Lausen, 2004]. This included industrial strength systems [Angele, 2014], W3C member submissions [de Bruijn et al., 2005], research investigations (e.g., [Fried- land et al., 2004; Roman et al., 2005]), and industrial applications (e.g., [Angele and Gesmann, 2007; Angele et al., 2008]). Central to F-Logic is its use of a frame- based syntax. RuleML,8 the Rule Markup Initiative, is another long-standing effort which aims at developing the Rule Markup Language RuleML “as the canonical Web language for rules using XML markup, formal semantics, and efficient implemen- tations” (cited from http://ruleml.org). RuleML is set to encompass the entire rule spectrum. The Semantic Web Rules Language SWRL [Horrocks et al., 2004; Horrocks et al., 2005b] has been presented in the aftermath of the W3C OWL specification, as an early effort to accomodate rules modeling in a way compatible with the descrip- tion logic paradigm. In its original formulation, SWRL simply added rules with a first-order predicate logic semantics to OWL, but reasoning systems and research discussions soon converged towards reading SWRL rules in a more restricted way, known as DL-safety, which was more akin to the Herbrand semantics usually con- sidered in logic programming, was more readily implementable, and retained a key design rationale of description logics, namely decidability [Motik et al., 2005; Krisnadhi et al., 2011]. SWRL became rather prominent in the wake of OWL, and the notion of DL-safety provided a key notion towards subsequent research into the integration of description logics and rules – see Section 6 for pointers to more recent developments on this issue. The RIF [Kifer and Boley, 2013] was finally estab- lished as a W3C recommended standard for exchanging rules between rule sys- tems. It draws, in part, on both F-Logic and RuleML.9 In particular, it sports a frame-based syntax inspired by F-Logic and draws from RuleML for its normative XML-based syntax. Set up as an exchange language, rather than as a full-blown knowledge representation language, RIF has several dialects as well as an exten- sible framework. Of the dialects, RIF Core [Boley et al., 2013] corresponds to Datalog, RIF BLD (the Basic Logic Dialect) [Boley and Kifer, 2013a] corresponds to Horn logic, and RIF PRD (the Production Rule Dialect) [de Sainte Marie et

8http://ruleml.org 9See [Kifer, 2008] and section 3.4 of http://www.w3.org/2005/rules/wiki/RIF FAQ. 20 Pascal Hitzler, Jens Lehmann, Axel Polleres al., 2013] captures main aspects of production rule systems [Klahr et al., 1987] which incorporate ad-hoc computational mechanisms (such as side-actions - gered by rule execusions, e.g. printing a document). Each of these dialects, even the strongly logic-based ones RIF Core and RIF BLD, sport some use of datatypes and built-ins. RIF FLD (the Framework for Logic Dialects) [Boley and Kifer, 2013b; Kifer, 2008] provides a means to define further RIF dialects. Finally, as discussed above, we note that the RDFS semantics is expressible in terms of Horn rules. On top of that, the W3C has defined a combined seman- tics for combining arbitrary Horn rules encoded in RIF [Boley and Kifer, 2013a] with RDF(S) and OWL [de Bruijn, 2013]. In the academic literature there have been several other proposals to extend RDF by rules beyond Horn rules, such as ERDF [Analyti et al., 2008] which provides a syntax for normal logic programs (that is, rules with default negation interpreted under the stable model seman- tics [Gelfond and Lifschitz, 1988]), or N3 [Berners-Lee et al., 2008] which also allows default negation in rule bodies; although N3’s semantics is only defined informally, its reference implementation CWM10 implements the perfect model semantics [Przymusinski, 1988]).11

5 PARTICULAR CHALLENGES TO USING LOGIC-BASED KNOWLEDGE REPRESENTATION ON THE WEB

The use of logic-based knowledge representation and reasoning at the scale of the World Wide Web poses a number of particular challenges which have so far not received primary attention in logic research. We list some of them in the following. The added value of a good machine-processable syntax for knowledge represen- tation formalisms is easily underestimated. However, it is a fundamental basis for knowledge exchange and integration which needs to be approached carefully in or- der to obtain a widest possible agreement between stakeholders. The World Wide Web Consortium has gone a long way in establishing recommended standards for knowledge representation for the Semantic Web, in particular through their work on RDF [Lassila and Swick, 2004; Cyganiak and Wood, 2013], OWL [Smith et al., 2004; Hitzler et al., 2012], and RIF [Boley et al., 2013; Boley and Kifer, 2013a], but also by establishing special-purpose shared vocabularies based on these, e.g. SKOS Simple Knowledge Organization System [Miles and Bechhofer, 2009], SSN Semantic Sensor Networks [Compton et al., 2012], provenance [Groth and Moreau, 2010]. Investigating the scalability of automated reasoning approaches is, of course, an established line of research in computer science. However, dealing with Web scale data lifts this issue to yet another level. Shared memory parallelization of reasoning is highly effective [Kazakov et al., 2011], however it breaks down if data size exceeds capacities. Massive distributed memory parallelization has started to

10http://www.w3.org/2000/10/swap/doc/cwm.html 11according to personal communication with Dan Connolly. Logics for the Semantic Web 21 be investigated [Mutharaju et al., 2013; Schlicht and Stuckenschmidt, 2010; Urbani et al., 2011; Urbani et al., 2012; Weaver and Hendler, 2009; Zhou et al., 2012], but there is as yet insufficient data for casting a verdict if distributed memory reasoning will be able to meet this challenge. Some authors even call for the investigation of non-deductive methods, e.g. borrowed from machine learning or , as a partial replacement for deductive approaches [Hitzler and van Harmelen, 2010]. Automated reasoning applications usually rely on clean, single-purpose, and usually manually created or curated knowledge bases. In a Web setting, how- ever, it would often be an unrealistic assumption that such input would be avail- able, or would be of sufficiently small volume to make manual curation a fea- sible approach. In some cases, this problem may be reduced by crowdsourcing data curation [Acosta et al., 2013]. Nevertheless, on the Web we should expect high-volume or high-throughput input which at the same time is multi-authored, multi-purposed, context-dependent, contains errors and omissions, and so forth [Hitzler and van Harmelen, 2010; Janowicz and Hitzler, 2012]. The aspects just mentioned are often refered to as the volume (size of input data), velocity (speed of data generation) and variety aspects of data, in fact these three V’s are usually discussed within the much larger Big Data context, within which many Semantic Web challenges can be located [Hitzler and Janowicz, 2013]. To give just one example of variety which is particularly challenging in a Se- mantic Web context, consider basic geographical notions such as forest, river, or village, which depend heavily on social agreement and tradition, and are further- more often influenced by economic or political incentives [Janowicz and Hitzler, 2012]. This type of variety is often refered to as semantic heterogeneity, and it cannot be overcome by simply enforcing a single definition: In fact, the different perspectives are often incompatible and would result in logical inconsistencies if combined. Research on the quesion how to deal with semantic heterogeneity may, of course, be more a question of pragmatics than of formal logic, yet the body of literature dealing with this issue is still too small to confidently locate ma- jor promising approaches. Formal logical approaches which have been proposed as partial solutions include fuzzy or probabilistic logics [Klinov and Parsia, 2008; Lukasiewicz and Straccia, 2009; Straccia, 2001], paraconsistent reasoning [Maier et al., 2013], and the use of defaults or other non-monotonic logics related to reason- ing with knowledge and belief [Baader and Hollunder, 1995; Bonatti et al., 2009; Donini et al., 2002; Eiter et al., 2008a; Knorr et al., 2011; Motik and Rosati, 2010; Sengupta et al., 2011], but the larger issue remains unresolved. Others have ad- vocated the use of ontology design patterns for meeting the challenge of semantic heterogeneity [Gangemi, 2005; Janowicz and Hitzler, 2012], but it is currently not clear how far this will carry. There exist a multitude of different knowledge representation paradigms based on different and often incompatible design principles. Logical features which ap- pear useful for modeling such as uncertainty handling or autoepistemic introspec- tion are often studied in isolation, while the high-variety setting of the Semantic Web would suggest that combinations of features need to be taken into account in 22 Pascal Hitzler, Jens Lehmann, Axel Polleres realistic settings. However, merging different knowledge representation paradigms often results in unwieldy, highly complex logics for which strong automated reason- ing support may be difficult to obtain [de Bruijn et al., 2011; de Bruijn et al., 2010; Knorr et al., 2012]. Even W3C recommended standards, which on purpose are designed to be of limited variety, expose this issue. The OWL 2 DL profile is essentially a traditional description logic, but if serialised in RDF (as required by the standard), the RDF formal semantics is not equivalent to the OWL formal semantics, and the sets of logical consequences defined by these two formal se- mantics for an OWL file (serialised in RDF) are not contained within each other. The OWL 2 Full profile was established to encompass all of both OWL 2 DL and RDF Schema, but we are not aware of any practical use of its formal semantics. Concerning the relationship between OWL and RIF, in contrast, the gap seems to be closing now, as discussed in Section 6 below. Another practical obstacle to the use of formal logic and reasoning on the Se- mantic Web is the availability of strong and intuitive tools and interfaces, of in- dustrial strength, which would relieve application developers from the burden of becoming an expert in formal logic and Semantic Web technologies. Of course, many useful tools are available, e.g. [Lehmann, 2009; Calvanese et al., 2011; David et al., 2011; Horridge and Bechhofer, 2011; Tudorache et al., 2013], and some of them are of excellent quality, but a significant gap remains to meet prac- tical requirements.

6 RECENT DEVELOPMENTS

Concerning more recent developments and investigations concerning the use of logic-based knowledge representation for the Semantic Web, it appears to make sense to distinguish between theoretical advances and advances concerning dis- semination into practice and applications. On the theory side, a convergence of different paradigms is currently happen- ing, in particular with respect to the description-logic-based and the rule-based paradigm. The following are some of the most prominent recent developments. • The introduction of role chains and some other constructs in OWL 2 [Hitzler et al., 2012] has made a significant step towards closing the gap between Horn logic and description logics, by making many more rules expressible in major description logics [Kr¨otzsch et al., 2008; Kr¨otzsch, 2010]. Another recently introduced syntax construct, called nominal schemas [Carral Mart´ınez et al., 2012; Carral et al., 2013], further enables the expression of many monotonic rules [Krisnadhi et al., 2011], up to a complete coverage of n-ary Datalog under the Herbrand semantics [Knorr et al., 2012]. Research concerning algorithmization and reasoning tool support are under way [Kr¨otzsch et al., 2011; Steigmiller et al., 2013]. • Datalog has recently seen a revival due to results investigating the theoretical and practical implications of adding existentially quantified variables to rule Logics for the Semantic Web 23

heads. The general approach is known as existential rules and was most prominently introduced under the name Datalog+− [Cal`ı et al., 2012]. The paradigm on the one hand generalizes Datalog, and on the other hand is very akin in spirit to the so-called EL family of description logics which entered the mainstream with the introduction of the tractable12 description logic EL++ [Baader et al., 2005] and its applications [Baader et al., 2006] – a line of work which eventually led to the OWL 2 profile known as OWL EL [Motik et al., 27 October 2009]. Currently, existential rules are under investigation from many different angles and by researchers of different backgrounds.

• Rule paradigms, and in particular logic programming in its many variants, have long been investigated from the perspective of non-monotonic logics, in particular in order to deal with types of commonsense reasoning related to defaults. Similar investgations have been pursued in recent years in order to extend description logics with such non-monotonic features, resulting in a significant body of work (e.g., [Baader and Hollunder, 1995; Bonatti et al., 2009; Donini et al., 2002; Eiter et al., 2008a; Giordano et al., 2013; Grimm and Hitzler, 2008; Huang et al., 2013; Knorr et al., 2011; Lukasiewicz and Straccia, 2009; Motik and Rosati, 2010; Sengupta et al., 2011]) which seems to converge towards a unifying perspective [de Bruijn et al., 2010; Knorr et al., 2012].

The situation concerning the dissemination of logic-based methods to Web prac- tice is much less clear, partly because these types of investigations are mainly industry-driven and thus often not well documented in the research literature. RDF-based reasoning is often being used, as existing RDF triple stores often pro- vide the required support. The use of ontologies in expert-system-like applica- tions is also rather common, in particular in industrial settings where input data is more controlled or curateable. So-called ontology-based data access (OBDA) [Calvanese et al., 2011], which rests on the idea of using shared ontologies as access layers for , is currently under heavy research investigation and will likely stay so for some time. For use of deep KR on the open Web major challenges remain [Noy and McGuinness, 2013; Hitzler and van Harmelen, 2010; Jain et al., 2010] which range from logical issues, e.g. how to deal with noisy data, to pragmatic issues, e.g. the development of modeling best practices and strong tool support.

Adding contextual information to RDF(S), OWL and SPARQL A particularly relevant topic that has appeared in various disguises over the years is the lack of means to express contextual information alongside RDF(S)& OWL Various approaches have been proposed in the literature to extend RDF(S), OWL

12To be precise, the worst-case computational complexity of computing the class hierarchy of all named classes is polynomial with respect to time. 24 Pascal Hitzler, Jens Lehmann, Axel Polleres and SPARQL by contextual information such as temporal information associ- ated to RDF triples [Gutierrez et al., 2007] and OWL statements [Motik, 2012], fuzzy annotations [Vanekov´a et al., 2005; Mazzieri and Dragoni, 2005; Straccia, 2009], or defining more general forms of “Annotated RDF” [Udrea et al., 2010; Zimmermann et al., 2012]. Note that the importance of adding such contextual meta-information to RDF data at the level of triples is also a topic within the ongoing developments within RDF1.1 [Herman, 2009], where not only the se- mantics of such extensions, but also their syntactic representation within RDF is under discussion; while the basic RDF vocabulary offers the possibility to add meta-descriptions through so-called reification, supported by special vocabulary terms (rdfs:Statement, rdfs:subject, rdfs:predicate, rdfs:object), these vocabulary terms are not given any special semantics and are often perceived as cumbersome in practice. Alternative proposals for expresssing contextualy infor- mation include so-called named graphs [Carroll et al., 2005], i.e., using again URIs to identify RDF graphs themselves, which then allows to use those identifiers in RDF triples to add contextual meta-information to the triples in these graphs; different syntax proposals for named graphs include N3 [Berners-Lee et al., 2008], TRIG/TRIX [Carothers et al., 2013; Carroll et al., 2005], and N-Quads [Carothers, 2013].

ACKNOWLEDGEMENTS

Pascal Hitzler acknowledges support by the National Science Foundation under award 1017225 ”III: Small: TROn – Tractable Reasoning with Ontologies.” Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation. Jens Lehmann acknowledges support by grants from the European Union’s 7th Framework Programme provided for the projects GeoKnow (GA no. 318159) and LOD2 (GA no. 257943).

BIBLIOGRAPHY

[Acosta et al., 2013] Maribel Acosta, Amrapali Zaveri, Elena Simperl, Dimitris Kontokostas, S¨orenAuer, and Jens Lehmann. Crowdsourcing quality assessment. In 12th International Semantic Web Conference, 21-25 October 2013, Sydney, Australia, 2013. [Analyti et al., 2008] Anastasia Analyti, Grigoris Antoniou, Carlos Viegas Dam´asio,and Gerd Wagner. Extended RDF as a semantic foundation of rule markup languages. J. Artif. Intell. Res. (JAIR), 32:37–94, 2008. [Angele and Gesmann, 2007] J¨urgenAngele and Michael Gesmann. Integration of customer information using the semantic web. In Jorge Cardoso, Martin Hepp, and Miltiadis D. Lytras, editors, The Semantic Web: Real-World Applications from Industry, volume 6 of Semantic Web And Beyond Computing for Human Experience, pages 191–208. Springer, 2007. [Angele and Lausen, 2004] J¨urgenAngele and Georg Lausen. Ontologies in F-Logic. In Stef- fen Staab and Rudi Studer, editors, Handbook on Ontologies, International Handbooks on Information Systems, pages 29–50. Springer, 2004. [Angele et al., 2008] J¨urgenAngele, Michael Erdmann, and Dirk Wenke. Ontology-based knowl- edge management in automotive engineering scenarios. In Martin Hepp, Pieter De Leenheer, Logics for the Semantic Web 25

Aldo de Moor, and York Sure, editors, Ontology Management, Semantic Web, Semantic Web Services, and Business Applications, volume 7 of Semantic Web And Beyond Computing for Human Experience, pages 245–264. Springer, 2008. [Angele, 2014] J¨urgenAngele. OntoBroker – mature and approved semantic middleware. Se- mantic Web journal, 2014. To appear. [Angles and Gutierrez, 2008] Renzo Angles and Claudio Gutierrez. The expressive power of SPARQL. In Amit P. Sheth, Steffen Staab, Mike Dean, Massimo Paolucci, Diana Maynard, Timothy W. Finin, and Krishnaprasad Thirunarayan, editors, International Semantic Web Conference (ISWC 2008), volume 5318 of LNCS, pages 114–129, Karlsruhe, Germany, 2008. Springer. [Baader and Hollunder, 1995] F. Baader and B. Hollunder. Embedding Defaults into Termino- logical Representation Systems. J. Automated Reasoning, 14:149–180, 1995. [Baader et al., 2005] Franz Baader, Sebastian Brandt, and Carsten Lutz. Pushing the EL en- velope. In Proc. 19th Int. Joint Conf. on Artificial Intelligence (IJCAI-05), Edinburgh, UK, 2005. Morgan-Kaufmann Publishers. [Baader et al., 2006] F. Baader, C. Lutz, and B. Suntisrivaraporn. CEL—A Polynomial-time Reasoner for Life Science Ontologies. In U. Furbach and N. Shankar, editors, Proceedings of the 3rd International Joint Conference on Automated Reasoning (IJCAR’06), Seattle, WA, USA, August 17-20, 2006, volume 4130 of Lecture Notes in Artificial Intelligence, pages 287–291. Springer-Verlag, 2006. [Baader, 2003] Franz Baader. The description logic handbook: theory, implementation, and applications. Cambridge University Press, 2003. [Beckett and Berners-Lee, 2011] David Beckett and Tim Berners-Lee. Turtle – Terse RDF Triple Language. W3C Team Submission, March 2011. http://www.w3.org/TeamSubmission/ turtle/. [Beckett and McBride, 2004a] David Beckett and Brian McBride. RDF Test Cases. W3C Rec- ommendation, February 2004. http://www.w3.org/TR/rdf-testcases/. [Beckett and McBride, 2004b] David Beckett and Brian McBride. RDF/XML Syntax Spec- ification (Revised). W3C Recommendation, February 2004. http://www.w3.org/TR/ rdf-syntax-grammar/. [Berners-Lee and Fischetti, 1999] Tim Berners-Lee and Marc Fischetti. Weaving the Web: The Original Design and Ultimate Destiny of the World Wide Web by its Inventor. Harper, 1999. [Berners-Lee et al., 2001] Tim Berners-Lee, James Hendler, and . The Semantic Web. Scientific American, 284(5):34–43, May 2001. [Berners-Lee et al., 2005] T. Berners-Lee, R. Fielding, and L. Masinter. Uniform resource iden- tifier (uri): Generic syntax. Technical Report RFC 3986, IETF, January 2005. http: //www.ietf.org/rfc/rfc3986.txt. [Berners-Lee et al., 2008] Tim Berners-Lee, Dan Connolly, Lalana Kagal, Yosi Scharf, and Jim Hendler. N3logic: A logical framework for the world wide web. TPLP, 8(3):249–269, 2008. [Berners-Lee, 1993] Tim Berners-Lee. A Brief History of the Web. W3C Design Issues, 1993. From http://www.w3.org/DesignIssues/TimBook-old/History.html; retr. 2013/09/24. [Berners-Lee, 1994] Tim Berners-Lee. Plenary at WWW Geneva 94. http://www.w3.org/Talks/WWW94Tim/, 1994. [Berners-Lee, 1996] Tim Berners-Lee. The World Wide Web: Past, present and future. http://www.w3.org/People/Berners-Lee/1996/ppf.html, August 1996. [Berners-Lee, 2006] Tim Berners-Lee. Linked Data. W3C Design Issues, July 2006. From http://www.w3.org/DesignIssues/LinkedData.html; retr. 2013/09/24. [Biron and Malhotra, 2004] Paul V. Biron and Ashok Malhotra. XML Schema part 2: Datatypes second edition. W3C Recommendation, October 2004. http://www.w3.org/TR/ xmlschema-2/. [Boley and Kifer, 2013a] Harold Boley and Michael Kifer, editors. RIF Basic Logic Di- alect (Second Edition). W3C Recommendation 5 February 2013, 2013. Available from http://www.w3.org/TR/rif-bld/. [Boley and Kifer, 2013b] Harold Boley and Michael Kifer, editors. RIF Framework for Logic Dialects (Second Edition). W3C Recommendation 5 February 2013, 2013. Available from http://www.w3.org/TR/rif-fld/. [Boley et al., 2013] Harold Boley, Gary Hallmark, Michael Kifer, Adrian Paschke, Axel Polleres, and Dave Reynolds, editors. RIF Core Dialect (Second Edition). W3C Recommendation 5 February 2013, 2013. Available from http://www.w3.org/TR/rif-core/. 26 Pascal Hitzler, Jens Lehmann, Axel Polleres

[Bonatti et al., 2009] Piero A. Bonatti, Carsten Lutz, and Frank Wolter. The Complexity of Circumscription in Description Logic. Journal of Artificial Intelligence Research, 35:717–773, 2009. [Brachman and Schmolze, 1985] Ronald J Brachman and James G Schmolze. An overview of the kl-one knowledge representation system*. Cognitive science, 9(2):171–216, 1985. [Brachman, 1978] Ronald J. Brachman. A structural paradigm for representing knowledge. Technical Report BBN Report 3605, Bolt, Beraneck and Newman, Inc., Cambridge, MA, 1978. [Brickley and Guha, 2004] Dan Brickley and R.V. Guha. RDF Vocabulary Description Lan- guage 1.0: RDF Schema. W3C Recommendation, February 2004. http://www.w3.org/TR/ rdf-schema/. [Brickley and Miller, 2007] Dan Brickley and Libby Miller. FOAF Vocabulary Specification, November 2007. [Cal`ı et al., 2012] Andrea Cal`ı,Georg Gottlob, and Thomas Lukasiewicz. A general datalog- based framework for tractable query answering over ontologies. Journal of Web Semantics, 14:57–83, 2012. [Calvanese et al., 2007] D. Calvanese, G. De Giacomo, D. Lembo, M. Lenzerini, and R. Rosati. Tractable reasoning and efficient query answering in description logics: The DL-Lite family. Journal of Automated reasoning, 39(3):385–429, 2007. [Calvanese et al., 2011] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, Antonella Poggi, Mariano Rodriguez-Muro, Riccardo Rosati, Marco Ruzzi, and Domenico Fabio Savo. The MASTRO system for ontology-based data access. Semantic Web, 2(1):43–53, 2011. [Carothers et al., 2013] Gavin Carothers, Andy Seaborne, Chris Bizer, and Richard Cyganiak. TriG RDF Dataset Language. W3C Last Call Working Draft, September 2013. http://www. w3.org/TR/2013/WD-trig-20130919/. [Carothers, 2013] Gavin Carothers. N-Quads A line-based syntax for an RDF datasets. W3C Last Call Working Draft, September 2013. http://www.w3.org/TR/2013/ WD-n-quads-20130905/. [Carral et al., 2013] David Carral, Cong Wang, and Pascal Hitzler. Towards an efficient algo- rithm to reason over description logics extended with nominal schemas. In Wolfgang Faber and Domenico Lembo, editors, Web Reasoning and Rule Systems – 7th International Confer- ence, RR 2013, Mannheim, Germany, July 27-29, 2013. Proceedings, volume 7994 of Lecture Notes in Computer Science, pages 65–79. Springer, 2013. [Carral Mart´ınez et al., 2012] David Carral Mart´ınez,Adila Alfa Krisnadhi, and Pascal Hitzler. Integrating OWL and rules: A syntax proposal for nominal schemas. In Pavel Klinov and Matthew Horridge, editors, Proceedings of OWL: Experiences and Directions Workshop 2012, Heraklion, Crete, Greece, May 27-28, 2012, volume 849 of CEUR Workshop Proceedings. CEUR-WS.org, 2012. [Carroll et al., 2005] Jeremy J. Carroll, Christian Bizer, Patrick J. Hayes, and Patrick Stickler. Named graphs. Journal of Web Semantics, 3(4):247–267, 2005. [Chandra and Merlin, 1977] Ashok K. Chandra and Philip M. Merlin. Optimal implementation of conjunctive queries in relational data bases. In John E. Hopcroft, Emily P. Friedman, and Michael A. Harrison, editors, Proceedings of the 9th Annual ACM Symposium on Theory of Computing (STOC), pages 77–90, Boulder, Colorado, USA, 1977. ACM. [Compton et al., 2012] Michael Compton, Payam M. Barnaghi, Luis Bermudez, Raul Garcia- Castro, Oscar´ Corcho, Simon Cox, John Graybeal, Manfred Hauswirth, Cory A. Henson, Arthur Herzog, Vincent A. Huang, Krzysztof Janowicz, W. David Kelsey, Danh Le Phuoc, Laurent Lefort, Myriam Leggieri, Holger Neuhaus, Andriy Nikolov, Kevin R. Page, Alexandre Passant, Amit P. Sheth, and Kerry Taylor. The SSN ontology of the W3C semantic sensor network incubator group. Journal of Web Semantics, 17:25–32, 2012. [Cyganiak and Wood, 2013] R. Cyganiak and D. Wood. RDF 1.1 Concepts and Ab- stract Syntax. W3C Last Call Working Draft 23 July 2013, 2013. Available from http://www.w3.org/TR/2013/WD-rdf11-concepts-20130723/. [David et al., 2011] J´erˆomeDavid, J´erˆomeEuzenat, Fran¸coisScharffe, and C´assiaTrojahn dos Santos. The Alignment API 4.0. Semantic Web, 2(1):3–10, 2011. Logics for the Semantic Web 27

[de Bruijn and Heymans, 2007] Jos de Bruijn and Stijn Heymans. Logical foundations of (e)RDF(S): Complexity and reasoning. In Proceedings of the 6th International Semantic Web Conference (ISWC2007), volume 4825 of LNCS, pages 86–99, 2007. [de Bruijn and Heymans, 2010] Jos de Bruijn and Stijn Heymans. Logical foundations of RDF(S) with datatypes. Journal of Artificial Intelligence Research (JAIR), 38:535–568, 2010. [de Bruijn et al., 2005] Jos de Bruijn, J¨urgenAngele, Harold Boley, Dieter Fensel, Pascal Hit- zler, Michael Kifer, Reto Krummenacher, Holger Lausen, Axel Polleres, and Rudi Studer. Web Rule Language (WRL). W3C Member Submission 09 September 2005, 2005. Available from http://www.w3.org/Submission/WRL. [de Bruijn et al., 2010] Jos de Bruijn, David Pearce, Axel Polleres, and Agust´ınValverde. A semantical framework for hybrid knowledge bases. Knowl. Inf. Syst., 25(1):81–104, 2010. [de Bruijn et al., 2011] Jos de Bruijn, Thomas Eiter, Axel Polleres, and Hans Tompits. Em- bedding nonground logic programs into autoepistemic logic for knowledge-base combination. ACM Trans. Comput. Log., 12(3), 2011. [de Bruijn, 2013] Jos de Bruijn. RIF RDF and OWL Compatibility (Second Edition). W3C Recommendation, February 2013. http://www.w3.org/TR/rif-rdf-owl/. [de Sainte Marie et al., 2013] Christian de Sainte Marie, Gary Hallmark, and Adrian Paschke, editors. RIF Production Rule Dialect (Second Edition). W3C Recommendation 5 February 2013, 2013. Available from http://www.w3.org/TR/rif-prd/. [Donini et al., 2002] F.M. Donini, D. Nardi, and R. Rosati. Description Logics of Minimal Knowledge and Negation as Failure. ACM Transactions on Computational Logic, 3(2):177– 225, 2002. [Eiter et al., 2008a] T. Eiter, G. Ianni, T. Lukasiewicz, R. Schindlauer, and H. Tompits. Com- bining answer set programming with description logics for the semantic web. Artificial Intel- ligence, 172(12–13):1495–1539, 2008. [Eiter et al., 2008b] Thomas Eiter, Giovambattista Ianni, Thomas Krennwallner, and Axel Polleres. Rules and ontologies for the semantic web. In Cristina Baroglio, Piero A. Bonatti, Jan Maluszynski, Massimo Marchiori, Axel Polleres, and Sebastian Schaffert, editors, Rea- soning Web 2008, volume 5224 of LNCS, pages 1–53. Springer, San Servolo Island, Venice, Italy, September 2008. [Ellerman, 1997] Castedo Ellerman. Channel definition format (CDF). W3C Member Submis- sion, March 1997. http://www.w3.org/TR/NOTE-CDFsubmit.html. [Fensel et al., 2001] Dieter Fensel, Frank Van Harmelen, Ian Horrocks, Deborah L McGuinness, and Peter F Patel-Schneider. OIL: An ontology infrastructure for the semantic web. Intelligent Systems, IEEE, 16(2):38–45, 2001. [Franconi et al., 2005] Enrico Franconi, Jos de Bruijn, and Sergio Tessaris. Logical reconstruc- tion of normative RDF. In Workshop on OWL: Experiences and Directions (OWLED’05), 2005. [Franconi et al., 2013] Enrico Franconi, Claudio Gutierrez, Alessandro Mosca, Giuseppe Pirr`o, and Riccardo Rosati. The logic of extensional RDFS. In The Semantic Web-ISWC 2013, pages 101–116. Springer, 2013. [Friedland et al., 2004] Noah S. Friedland, Paul G. Allen, Gavin Matthews, Michael J. Wit- brock, David Baxter, Jon Curtis, Blake Shepard, Pierluigi Miraglia, J¨urgenAngele, Steffen Staab, Eddie M¨onch, Henrik Oppermann, Dirk Wenke, David J. Israel, Vinay K. Chaudhri, Bruce W. Porter, Ken Barker, James Fan, Shaw Yi Chaw, Peter Z. Yeh, Dan Tecuci, and Peter Clark. Project Halo: Towards a digital Aristotle. AI Magazine, 25(4):29–48, 2004. [Gangemi, 2005] Aldo Gangemi. Ontology design patterns for semantic web content. In Yolanda Gil, Enrico Motta, V. Richard Benjamins, and Mark A. Musen, editors, The Semantic Web – ISWC 2005, 4th International Semantic Web Conference, ISWC 2005, Galway, Ireland, November 6-10, 2005, Proceedings, volume 3729 of Lecture Notes in Computer Science, pages 262–276. Springer, 2005. [Garey and Johnson, 1979] Michael R. Garey and David S. Johnson. Computers and Intractabil- ity: A Guide to the Theory of NP-Completeness. W. H. Freeman and Company, 1979. [Gelfond and Lifschitz, 1988] Michael Gelfond and Vladimir Lifschitz. The stable model se- mantics for logic programming. In Robert A. Kowalski and Kenneth Bowen, editors, 5th Int’l Conf. on Logic Programming, pages 1070–1080, Cambridge, Massachusetts, 1988. The MIT Press. 28 Pascal Hitzler, Jens Lehmann, Axel Polleres

[Giordano et al., 2013] Laura Giordano, Valentina Gliozzi, Nicola Olivetti, and Gian Luca Poz- zato. A non-monotonic description logic for reasoning about typicality. Artificial Intelligence, 195:165–202, 2013. [Grau et al., 2008] Bernardo Cuenca Grau, Ian Horrocks, Boris Motik, Bijan Parsia, Peter Patel-Schneider, and Ulrike Sattler. OWL 2: The next step for OWL. Journal of Web Semantics, 6(4):309–322, 2008. [Grimm and Hitzler, 2008] Stephan Grimm and Pascal Hitzler. Semantic Matchmaking of Web Resources with Local Closed-World Reasoning. International Journal of Electronic Com- merce, 12(2):89–126, 2008. [Groth and Moreau, 2010] Paul Groth and Luc Moreau, editors. PROV-Overview, An Overview of the PROV Family of Documents. W3C Working Group Note 30 April 2013, 2010. Available from http://www.w3.org/TR/prov-overview. [Guha and Bray, 1997] R.V. Guha and Tim Bray. Meta content framework using XML. W3C Member Submission, June 1997. http://www.w3.org/TR/NOTE-MCF-XML/. [Guti´errez et al., 2004] Claudio Guti´errez, Carlos A. Hurtado, and Alberto O. Mendelzon. Foun- dations of semantic web databases. In Proceedings of the 23rd ACM SIGACT-SIGMOD- SIGART Symposium on Principles of Database Systems (PODS2004), pages 95–106, 2004. [Gutierrez et al., 2007] Claudio Gutierrez, Carlos A. Hurtado, and Alejandro A. Vaisman. In- troducing time into RDF. IEEE Trans. Knowl. Data Eng., 19(2):207–218, 2007. [Hamby, 2012] Steve Hamby. 2012: The year of the Semantic Web – revisited! http://www.huffingtonpost.com/steve-hamby/2012-the-year-of-the-sema b 1559767.html, Jun 2012. [Harris and Seaborne, 2013] Steve Harris and Andy Seaborne. SPARQL 1.1 Query Language. W3C Recommendation, March 2013. http://www.w3.org/TR/sparql11-query/. [Hayes and Patel-Schneider, 2014] Patrick Hayes and Peter Patel-Schneider. RDF 1.1 Se- mantics. W3C Proposed Recommendation, January 2014. http://www.w3.org/TR/2014/ PR-rdf11-mt-20140109/. [Hayes, 2004] Patrick Hayes. RDF Semantics. W3C Recommendation, February 2004. http: //www.w3.org/TR/rdf-mt/. [Herman et al., 2013] Ivan Herman, Ben Adida, and Manu Sporny. RDFa 1.1 Primer. W3C Working Group Note, August 2013. http://www.w3.org/TR/xhtml-rdfa-primer/. [Herman, 2009] Ivan Herman. W3C Workshop – RDF Next Steps. Workshop Report, June 2009. http://www.w3.org/2009/12/rdf-ws/Report.html. [Hermann, 2010] Ivan Hermann. Semantic web adoption and applications. http://www.w3.org/People/Ivan/CorePresentations/Applications/, Nov 2010. [Hickson, 2012] Ian Hickson. HTML Microdata. W3C Working Draft, October 2012. http: //www.w3.org/TR/2012/WD-microdata-20121025/, work in progress, latest version available at http://www.w3.org/TR/microdata/. [Hitzler and Janowicz, 2013] Pascal Hitzler and Krzysztof Janowicz. Linked data, big data, and the 4th paradigm. Semantic Web, 4(3):233–235, 2013. [Hitzler and van Harmelen, 2010] Pascal Hitzler and Frank van Harmelen. A reasonable seman- tic web. Semantic Web, 1(1–2):39–44, 2010. [Hitzler et al., 2010] Pascal Hitzler, Markus Kr¨otzsch, and Sebastian Rudolph. Foundations of Semantic Web Technologies. Chapman & Hall/CRC, 2010. [Hitzler et al., 2012] Pascal Hitzler, Markus Kr¨otzsch, Bijan Parsia, Peter F. Patel-Schneider, and Sebastian Rudolph, editors. OWL 2 Web Ontology Language: Primer (Sec- ond Edition). W3C Recommendation 11 December 2012, 2012. Available from http://www.w3.org/TR/owl2-primer/. [Horridge and Bechhofer, 2011] Matthew Horridge and Sean Bechhofer. The OWL API: A Java API for OWL ontologies. Semantic Web, 2(1):11–21, 2011. [Horridge and Patel-Schneider, 2008] Matthew Horridge and Peter F. Patel-Schneider. Manch- ester syntax for OWL 1.1. In OWLED 2008, 4th international workshop OWL: Experiences and Directions, 2008. [Horrocks et al., 2003] Ian Horrocks, Peter F Patel-Schneider, and Frank Van Harmelen. From SHIQ and RDF to OWL: The making of a web ontology language. Web semantics: science, services and agents on the World Wide Web, 1(1):7–26, 2003. Logics for the Semantic Web 29

[Horrocks et al., 2004] Ian Horrocks, Peter F. Patel-Schneider, Harold Boley, Said Tabet, Benjamin Grosof, and Mike Dean. SWRL: A Semantic Web Rule Language Combin- ing OWL and RuleML. W3C Member Submission 21 May 2004, 2004. Available from http://www.w3.org/Submission/SWRL/. [Horrocks et al., 2005a] Ian Horrocks, Bijan Parsia, Peter F. Patel-Schneider, and James A. Hendler. Semantic web architecture: Stack or two towers? In 3rd International Workshop on Principles and Practice of Semantic Web Reasoning (PPSWR2005), volume 3703 of LNCS, pages 37–41. Springer, 2005. [Horrocks et al., 2005b] Ian Horrocks, Peter F. Patel-Schneider, Sean Bechhofer, and Dmitry Tsarkov. OWL rules: A proposal and prototype implementation. Journal of Web Semantics, 3:23–40, 2005. [Huang et al., 2013] Shasha Huang, Qingguo Li, and Pascal Hitzler. Reasoning with inconsis- tencies in hybrid MKNF knowledge bases. Logic Journal of the IGPL, 21(2):263–290, 2013. [Jain et al., 2010] Prateek Jain, Pascal Hitzler, Peter Z. Yeh, Kunal Verma, and Amit P. Sheth. Linked Data is Merely More Data. In Dan Brickley, Vinay K. Chaudhri, Harry Halpin, and Deborah McGuinness, editors, Linked Data Meets Artificial Intelligence, pages 82–86. AAAI Press, Menlo Park, CA, 2010. [Janowicz and Hitzler, 2012] Krzysztof Janowicz and Pascal Hitzler. The Digital Earth as knowledge engine. Semantic Web, 3(3):213–221, 2012. [Kazakov et al., 2011] Yevgeny Kazakov, Markus Kr¨otzsch, and FrantiˇsekSimanˇc´ık.Concurrent classification of EL ontologies. In Lora Aroyo, Chris Welty, Harith Alani, Jamie Taylor, Abraham Bernstein, Lalana Kagal, Natasha Noy, and Eva Blomqvist, editors, Proceedings of the 10th International Semantic Web Conference (ISWC’11), volume 7032 of LNCS. Springer, 2011. [Kifer and Boley, 2013] Michael Kifer and Harold Boley, editors. RIF Overview (Sec- ond Edition). W3C Working Group Note 5 February 2013, 2013. Available from http://www.w3.org/TR/rif-overview/. [Kifer et al., 1995] Michael Kifer, Geord Lausen, and James Wu. Logical foundations of object- oriented and frame-based languages. JACM, 42(4):741–843, 1995. [Kifer et al., 2005] Michael Kifer, Jos de Bruijn, Harold Boley, and Dieter Fensel. A realis- tic architecture for the semantic web. In 1st International Conference on Rules and Rule Markup Languages for the Semantic Web (RuleML2005), volume 3791 of LNCS, pages 17– 29. Springer, 2005. [Kifer, 2008] Michael Kifer. Rule Interchange Format: The framework. In Diego Calvanese and Georg Lausen, editors, Web Reasoning and Rule Systems, volume 5341 of Lecture Notes in Computer Science, pages 1–11. Springer, 2008. [Klahr et al., 1987] David Klahr, Pat Langley, and Robert Neches, editors. Production System Models of Learning and Development. Bradford, 1987. [Klinov and Parsia, 2008] Pavel Klinov and Bijan Parsia. Optimization and evaluation of rea- soning in probabilistic description logic: Towards a systematic approach. In Amit P. Sheth, Steffen Staab, Mike Dean, Massimo Paolucci, Diana Maynard, Timothy W. Finin, and Krish- naprasad Thirunarayan, editors, The Semantic Web – ISWC 2008, 7th International Seman- tic Web Conference, ISWC 2008, Karlsruhe, Germany, October 26-30, 2008. Proceedings, volume 5318 of Lecture Notes in Computer Science, pages 213–228. Springer, 2008. [Knorr et al., 2011] M. Knorr, J.J. Alferes, and P. Hitzler. Local closed-world reasoning with description logics under the well-founded semantics. Artificial Intelligence, 175(9–10):1528– 1554, 2011. [Knorr et al., 2012] M. Knorr, P. Hitzler, and F. Maier. Reconciling OWL and non-monotonic rules for the Semantic Web. In L. De Raedt, C. Bessiere, D. Dubois, P. Doherty, P. Fras- coni, F. Heintz, and P. Lucas, editors, ECAI 2012, 20th European Conference on Artificial Intelligence, 27-31 August 2012, Montpellier, France, volume 242 of Frontiers in Artificial Intelligence and Applications, pages 474–479. IOS Press, Amsterdam, 2012. [Krisnadhi et al., 2011] Adila Krisnadhi, Frederick Maier, and Pascal Hitzler. OWL and rules. In Axel Polleres, Claudia d’Amato, Marcelo Arenas, Siegfried Handschuh, Paula Kroner, Sascha Ossowski, and Peter F. Patel-Schneider, editors, Reasoning Web. Semantic Technologies for the Web of Data – 7th International Summer School 2011, Galway, Ireland, August 23-27, 2011, Tutorial Lectures, volume 6848 of Lecture Notes in Computer Science, pages 382–415. Springer, 2011. 30 Pascal Hitzler, Jens Lehmann, Axel Polleres

[Kr¨otzsch et al., 2008] Markus Kr¨otzsch, Sebastian Rudolph, and Pascal Hitzler. Description Logic Rules. In Malik Ghallab, Constantine D. Spyropoulos, Nikos Fakotakis, and Nikolaos M. Avouris, editors, Proceeding of the 18th European Conference on Artificial Intelligence, Pa- tras, Greece, July 21-25, 2008, volume 178, pages 80–84, Amsterdam, The Netherlands, 2008. IOS Press. [Kr¨otzsch et al., 2011] Markus Kr¨otzsch, Frederick Maier, Adila A. Krisnadhi, and Pascal Hit- zler. A better uncle for OWL: Nominal schemas for integrating rules and ontologies. In S. Sadagopan, Krithi Ramamritham, Arun Kumar, M.P. Ravindra, Elisa Bertino, and Ravi Kumar, editors, Proceedings of the 20th International World Wide Web Conference, WWW2011, Hyderabad, India, March/April 2011, pages 645–654. ACM, New York, 2011. [Kr¨otzsch, 2010] Markus Kr¨otzsch. Description Logic Rules, volume 008 of Studies on the Se- mantic Web. IOS Press/AKA, 2010. [Lassila and Swick, 1999] Ora Lassila and Ralph R. Swick. Resource Description Framework (RDF) Model and Syntax Specification. W3C Recommendation, February 1999. http:// www.w3.org/TR/1999/REC-rdf-syntax-19990222/. [Lassila and Swick, 2004] O. Lassila and R. R. Swick. Resource Description Framework (RDF) Model and Syntax Specification. W3C Recommendation 10 February 2004, 2004. Available from http://www.w3.org/TR/REC-rdf-syntax/. [Lehmann, 2009] Jens Lehmann. DL-Learner: learning concepts in description logics. Journal of Machine Learning Research (JMLR), 10:2639–2642, 2009. [Lukasiewicz and Straccia, 2009] Thomas Lukasiewicz and Umberto Straccia. Description logic programs under probabilistic uncertainty and fuzzy vagueness. Int. J. Approx. Reasoning, 50(6):837–853, 2009. [Maier et al., 2013] Frederick Maier, Yue Ma, and Pascal Hitzler. Paraconsistent OWL and related logics. Semantic Web, 4(4):395–427, 2013. [Mallea et al., 2011] Alejandro Mallea, Marcelo Arenas, Aidan Hogan, and Axel Polleres. On Blank Nodes. In Proceedings of the 10th International Semantic Web Conference (ISWC 2011), volume 7031 of LNCS. Springer, October 2011. [Manola et al., 2004] Frank Manola, Eric Miller, and Brian McBride. RDF Primer. W3C Rec- ommendation, February 2004. http://www.w3.org/TR/rdf-primer/. [Mazzieri and Dragoni, 2005] Mauro Mazzieri and Aldo Franco Dragoni. A Fuzzy Semantics for Semantic Web Languages. In Paulo Cesar G. da Costa, Kathryn B. Laskey, Kenneth J. Laskey, and Michael Pool, editors, ISWC-URSW, pages 12–22, 2005. [McGuinness et al., 2002] Deborah L McGuinness, Richard Fikes, James Hendler, and Lynn An- drea Stein. DAML+OIL: an ontology language for the semantic web. Intelligent Systems, IEEE, 17(5):72–80, 2002. [Miles and Bechhofer, 2009] A. Miles and S. Bechhofer, editors. SKOS Simple Knowledge Or- ganization System Reference. W3C Recommendation 18 August 2009, 2009. Available from http://www.w3.org/TR/skos-reference. [Minsky, 1975] Marvin Minsky. A framework for representing knowledge. In The Psychology of Computer Vision, pages 211–277. McGraw-Hill, 1975. [Motik and Horrocks, 2008] Boris Motik and Ian Horrocks. OWL datatypes: Design and imple- mentation. In The Semantic Web-ISWC 2008, pages 307–322. Springer, 2008. [Motik and Rosati, 2010] B. Motik and R. Rosati. Reconciling description logics and rules. Journal of the ACM, 57(5), 2010. [Motik et al., 2005] Boris Motik, Ulrike Sattler, and Rudi Studer. Query answering for OWL- DL with rules. Journal of Web Semantics: Science, Services and Agents on the World Wide Web, 3(1):41–60, 2005. [Motik et al., 27 October 2009] B. Motik, B. Cuenca Grau, I. Horrocks, Z. Wu, A. Fokoue, and C. Lutz, editors. OWL 2 Web Ontology Language: Profiles. W3C Recommendation, 27 October 2009. Available at http://www.w3.org/TR/owl2-profiles/. [Motik, 2012] Boris Motik. Representing and querying validity time in rdf and owl: A logic- based approach. J. Web Sem., 12:3–21, 2012. [Mu˜noz et al., 2007] Sergio Mu˜noz,Jorge P´erez,and Claudio Gutierrez. Minimal Deductive Systems for RDF. In Enrico Franconi, Michael Kifer, and Wolfgang May, editors, Proceedings of the 4th European Semantic Web Conference (ESWC 2007), volume 4519 of LNCS, pages 53–57, Innsbruck, Austria, June 2007. Logics for the Semantic Web 31

[Mutharaju et al., 2013] Raghava Mutharaju, Pascal Hitzler, and Prabhaker Mateti. DistEL: A distributed EL+ ontology classifier. In Thorsten Liebig and Achille Fokoue, editors, SSWS 2013, Scalable Semantic Web Knowledge Base Systems 2013. Proceedings of the 9th Inter- national Workshop on Scalable Semantic Web Knowledge Base Systems, co-located with the International Semantic Web Conference (ISWC 2013), Sydney, Australia, October 21, 2013, volume 1046 of CEUR Workshop Proceedings, pages 17–32, 2013. [Nilsson et al., 2008] Mikael Nilsson, Andy Powell, Pete Johnston, and Ambj¨ornNaeve. Ex- pressing Dublin Core metadata using the Resource Description Framework (RDF). DCMI Recommendation, January 2008. http://dublincore.org/documents/dc-rdf/. [Noy and McGuinness, 2013] Natasha Noy and Deborah McGuinness, editors. Final Report on the 2013 NSF Workshop on Research Challenges and Opportunities in Knowledge Represen- tation, Arlington, VA, February 7-8, 2013. National Science Foundation Workshop Report, 2013. [OWL Working Group, 11 December 2012] W3C OWL Working Group. OWL 2 Web Ontology Language Manchester Syntax (Second Edition). W3C Working Group Note, 11 December 2012. Available at http://www.w3.org/TR/owl2-manchester-syntax/. [OWL Working Group, 27 October 2009] W3C OWL Working Group. OWL 2 Web Ontology Language: Document Overview. W3C Recommendation, 27 October 2009. Available at http://www.w3.org/TR/owl2-overview/. [Phillips and Davis, 2006] A. Phillips and M. Davis. Tags for identifying languages. Technical Report BCP 47, IETF, September 2006. http://www.rfc-editor.org/rfc/bcp/bcp47.txt. [Pichler et al., 2008] Reinhard Pichler, Axel Polleres, Fang Wei, and Stefan Woltran. Entailment for domain-restricted RDF. In Proceedings of the 5th European Semantic Web Conference (ESWC2008), volume 5021 of LNCS, pages 200–214, Tenerife, Spain, 2008. Springer. [Poggi et al., 2008] Antonella Poggi, Domenico Lembo, Diego Calvanese, Giuseppe Giacomo, Maurizio Lenzerini, and Riccardo Rosati. Linking data to ontologies. In Stefano Spaccapietra, editor, Journal on Data Semantics X, volume 4900 of LNS, pages 133–173. Springer, 2008. [Polleres and Wallner, 2013] Axel Polleres and Johannes Wallner. On the relation between SPARQL1.1 and Answer Set Programming. Journal of Applied Non-Classical Logics (JANCL), 23(1–2):159–212, 2013. Special issue on Equilibrium Logic and Answer Set Pro- gramming. [Polleres et al., 2011] Axel Polleres, Claudia D’Amato, Marcelo Arenas, Siegfried Handschuh, Paula Kroner, Sascha Ossowski, and Peter Patel-Schneider, editors. Reasoning Web. Semantic Technologies for the Web of Data. (ReasoningWeb 2011), volume 6848 of LNCS. Springer, August 2011. [Prud’hommeaux, 2008] Eric Prud’hommeaux. SPARQL Query Language for RDF. W3C Rec- ommendation, January 2008. http://www.w3.org/TR/rdf-sparql-query/. [Przymusinski, 1988] Theodor C. Przymusinski. On the Declarative Semantics of Deductive Databases and Logic Programs. In Jack Minker, editor, Foundations of Deductive Databases and Logic Programming, pages 193–216. Morgan Kaufmann Publishers, Inc., 1988. [Roman et al., 2005] Dumitru Roman, Uwe Keller, Holger Lausen, Jos de Bruijn, Rub´enLara, Michael Stollberg, Axel Polleres, Cristina Feier, Christoph Bussler, and Dieter Fensel. Web Service Modeling Ontology. Applied Ontology, 1(1):77–106, 2005. [Schlicht and Stuckenschmidt, 2010] Anne Schlicht and Heiner Stuckenschmidt. Peer-to-peer reasoning for interlinked ontologies. Int. J. , 4(1):27–58, 2010. [Sengupta et al., 2011] Kunal Sengupta, Adila Alfa Krisnadhi, and Pascal Hitzler. Local Closed World Semantics: Grounded Circumscription for OWL. In Lora Aroyo, Chris Welty, Harith Alani, Jamie Taylor, Abraham Bernstein, Lalana Kagal, Natasha Fridman Noy, and Eva Blomqvist, editors, The Semantic Web – ISWC 2011 – 10th International Semantic Web Conference, Bonn, Germany, October 23-27, 2011, Proceedings, Part I, volume 7031 of Lec- ture Notes in Computer Science, pages 617–632. Springer, Heidelberg, 2011. [Smith et al., 2004] Michael K. Smith, Chris Welty, and Deborah L. McGuinness, editors. OWL Web Ontology Language Guide. W3C Recommendation 10 February 2004, 2004. Available from http://www.w3.org/TR/owl-guide/. [Steigmiller et al., 2013] Andreas Steigmiller, Birte Glimm, and Thorsten Liebig. Nominal schema absorption. In Francesca Rossi, editor, IJCAI 2013, Proceedings of the 23rd In- ternational Joint Conference on Artificial Intelligence, Beijing, China, August 3-9, 2013. IJCAI/AAAI, 2013. 32 Pascal Hitzler, Jens Lehmann, Axel Polleres

[Straccia, 2001] Umberto Straccia. Reasoning within fuzzy description logics. J. Artif. Intell. Res. (JAIR), 14:137–166, 2001. [Straccia, 2009] Umberto Straccia. A Minimal Deductive System for General Fuzzy RDF. In Axel Polleres and Terrance Swift, editors, Web Reasoning and Rule Systems, Third Interna- tional Conference, RR 2009, Chantilly, VA, USA, October 25-26, 2009, Proceedings, volume 5837 of LNCS, pages 166–181. Springer, 2009. [Studer, 2006] Rudi Studer. The Semantic Web: Suppliers and customers. In Isabel F. Cruz, Stefan Decker, Dean Allemang, Chris Preist, Daniel Schwabe, Peter Mika, Michael Uschold, and Lora Aroyo, editors, The Semantic Web – ISWC 2006, 5th International Semantic Web Conference, ISWC 2006, Athens, GA, USA, November 5-9, 2006, Proceedings, volume 4273 of Lecture Notes in Computer Science, pages 995–996. Springer, 2006. [Tudorache et al., 2013] Tania Tudorache, Csongor Nyulas, Natalya Fridman Noy, and Mark A. Musen. Webprot´eg´e:A collaborative ontology editor and knowledge acquisition tool for the web. Semantic Web, 4(1):89–99, 2013. [Udrea et al., 2010] Octavian Udrea, Diego Reforgiato Recupero, and V. S. Subrahmanian. An- notated RDF. ACM Transactions on Computational Logic, 11(2):1–41, 2010. [Urbani et al., 2011] Jacopo Urbani, Frank van Harmelen, Stefan Schlobach, and Henri E. Bal. Querypie: Backward reasoning for OWL Horst over very large knowledge bases. In Lora Aroyo, Chris Welty, Harith Alani, Jamie Taylor, Abraham Bernstein, Lalana Kagal, Natasha Fridman Noy, and Eva Blomqvist, editors, The Semantic Web – ISWC 2011 – 10th International Se- mantic Web Conference, Bonn, Germany, October 23-27, 2011, Proceedings, Part I, volume 7031 of Lecture Notes in Computer Science, pages 730–745. Springer, 2011. [Urbani et al., 2012] Jacopo Urbani, Spyros Kotoulas, Jason Maassen, Frank van Harmelen, and Henri E. Bal. WebPIE: A web-scale parallel inference engine using MapReduce. Journal of Web Semantics, 10:59–75, 2012. [Vanekov´a et al., 2005] Veronika Vanekov´a,J´anBella, Peter Gursk´y,and Tom´aˇsHorv´ath.Fuzzy RDF in the Semantic Web: Deduction and Induction. In 6th Slovak-Austrian Student Work- shop WDA ’05, pages 16–29. Elfa Academic Press, Ltd, 2005. [W3C Metadata, revision of 23 August 2002] Metadata Activity Statement. http://www.w3.org/Metadata/Activity, revision of 23 August 2002. [W3C Semantic Web, revision of 19 June 2013] W3C Semantic Web Activity. http://www.w3.org/2001/sw/, revision of 19 June 2013. [Weaver and Hendler, 2009] Jesse Weaver and James A. Hendler. Parallel materialization of the finite RDFS closure for hundreds of millions of triples. In Abraham Bernstein et al., editors, The Semantic Web – ISWC 2009, 8th International Semantic Web Conference, ISWC 2009, Chantilly, VA, USA, October 25-29, 2009, volume 5823 of Lecture Notes in Computer Science, pages 682–697. Springer, 2009. [Web Ontology Working Group, 10 February 2004] Web Ontology Working Group. OWL Web Ontology Language Overview. W3C Recommendation, 10 February 2004. Available at http: //www.w3.org/TR/owl-features/. [Zhou et al., 2012] Zhangquan Zhou, Guilin Qi, Chang Liu, Pascal Hitzler, and Raghava Mutharaju. Reasoning with Fuzzy-EL+ ontologies using MapReduce. In Luc De Raedt, Christian Bessi`ere,Didier Dubois, Patrick Doherty, Paolo Frasconi, Fredrik Heintz, and Pe- ter J. F. Lucas, editors, ECAI 2012 – 20th European Conference on Artificial Intelligence. Including Prestigious Applications of Artificial Intelligence (PAIS-2012) System Demonstra- tions Track, Montpellier, France, August 27-31 , 2012, volume 242 of Frontiers in Artificial Intelligence and Applications, pages 933–934. IOS Press, 2012. [Zimmermann et al., 2012] Antoine Zimmermann, Nuno Lopes, Axel Polleres, and Umberto Straccia. A general framework for representing, reasoning and querying with annotated se- mantic web data. Journal of Web Semantics (JWS), 12:72–95, March 2012.