Copyright © 2008 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is being published as one of a set of 53 documents:
This draft is ready for Working Group Review. A publication decision is scheduled for 15 April.
The Rule Interchange Format (RIF) Working Group seeks public feedback on these Working Drafts. Please send your comments to public-rif-comments@w3.org (public archive). If possible, please offer specific changes to the text that would address your concern. You may also wish to check the Wiki Version of this document for internal-review comments and changes being drafted which may address your concerns.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
Contents
|
The Rule Interchange Format (RIF), specifically the Basic Logic
Dialect (BLD) [(RIF-BLD ], defines), is a
meansformat for the interchange of (logical)interchanging logical rules over the Web. Rules whichthat are
exchanged using RIF may refer to external data sources and may be
based on certaindata models whichthat are represented using a language
different from RIF. The Resource Description Framework RDF [(RDF-Concepts ]) is a Web-based language for the
representation and exchange of data; RDF Schema
(RDFS) [(RDF-Schema ]) and the
Web Ontology Language OWL
[(OWL-Reference ]) are
Web-based languages for the representationrepresenting and exchange ofexchanging ontologies
(i.e., data models). This document specifies how combinations of
RIF BLD Rule setsRulesets and RDF data and RDFS and OWL ontologies must be
interpreted.interpreted; i.e., it specifies how RIF interoperates with
RDF/OWL.
The RIF working group plans to develop further dialects besides
BLD, most notably a dialect based on Production Rules [(RIF-PRD ];); these dialects are not
necessarily extensions of BLD. Future versions of this document willmay
address compatibility of these dialects with RDF and OWL as well.
In the remainder of the document, when mentioning RIF, we meanRIF is understood to refer to RIF
BLD [(RIF-BLD ].).
RDF data and RDFS and OWL ontologies are represented using
RDF graphs. Several syntaxes have been proposed for the
exchange of RDF graphs, the normative syntax being RDF/XML
[(RDF-Syntax ], which is an XML-based format.). RIF does not
provide a format for exchanging RDF;RDF graphs, since this would be a
duplication. Instead, it is assumed that RDF graphs are exchanged
using RDF/XML, or any other syntax that can be used for
representing or exchanging RDF graphs.
This document does not, as yet, define whether or how RDF documents/graphs should be referred to from RIF rule sets. The specification of combinations in this document does not depend on (the existence of) this mechanism: it applies in case an RIF rule sets explicity points to (one or more) RDF documents, but also in case the references to the RDF document(s) are not interchanged using RIF, but using some other (out of bounds) mechanism.A typical scenario for the use of RIF with RDF/OWL includesis the
exchange of rules whichthat either use RDF data or an RDFS or OWL
ontology. In terms of rule interchange the scenario is the following:ontology: an interchange partner A has a rules language whichthat
is RDF/OWL-aware, i.e., it allows tosupports the use of RDF data, it uses an
RDFS or OWL ontology, or it extends RDF(S)/OWL. A sends its
rules (using RIF),using RIF, possibly with a referencereferences to the appropriate RDF
graph(s), to partner B. B can now translatereceives the RIFrules into its own rules language, retrieveand
retrieves the referenced RDF graph(s) (which is published most likely using RDF/XML), and process(published as, e.g., RDF/XML
(RDF-SYNTAX)). The rules in its ownare
translated to the internal rules language of B and are
processed, together with the RDF graphs, using the RDF/OWL-aware
rule engine, which is also RDF/OWL-aware.engine of B. The use case
Vocabulary Mapping for Data Integration [(RIF-UCR ]) is an example of the interchange of RIF rules
whichthat use RDF graphs.data and RDFS ontologies.
A specialization of this use casescenario is the publication of RIF
rules whichthat refer to RDF graphs (notice thatgraphs: publication is a specificspecial kind of
interchange). In such a scenario,interchange. A rule publisher A publishes its rules on the
Web. There may be several consumers whothat retrieve the RIF rules and
RDF graphs from the Web, andtranslate the RIF rules to their own rules
languages.languages, and process them together with the RDF graphs in their
own rules engine. The use case
Publishing Rules for Interlinked Metadata [(RIF-UCR ] is an example of) illustrates the publication
of RIF rules related to RDF graphs.scenario.
Another specialization of this use casethe exchange scenario is the
interchange of rule extensions to OWL [(RIF-UCR ].). The intention of the rule publisher in this
scenario is to extend an OWL ontology with rules: interchange
partner A has a rules language that extends OWL. A
splits its ontology+rules description into a separate OWL ontology
and ana RIF rule set,ruleset, publishes the OWL ontology, and sends (or
publishes) the RIF rule set,ruleset, which includes a reference to the OWL
ontology. The consumersA consumer of the rules retrieves the OWL ontology,ontology and
translates the ontology and the rule setruleset into a combined ontology+rules
description in its own rules language which also extendsrule extension of OWL.
AnA RIF rule set whichruleset that refers to RDF graphs,graphs and/or RDFS/OWL ontologies,
or any use of ana RIF rule setruleset with RDF graphs, is viewed as a
combination of an RIF rule seta ruleset and a number of RDF graphs.graphs and ontologies.
This document specifies how, in such a combination, the rule set interacts withruleset and
the RDF graphs. With "interaction" we meangraphs and ontologies interoperate in a technical sense, i.e.,
the conditions under which the combination is satisfiable,satisfiable (i.e.,
consistent), as well as the entailments defined for(i.e., logical
consequences) of the combination. The interaction between RIF and
RDF and OWLRDF/OWL is realized by connecting the model theory of RIF
(specified in [(RIF-BLD ]))) with
the model theories of RDF (specified in [(RDF-Semantics ]))) and OWL
(specified in [(OWL-Semantics ]),)), respectively.
The RDF semantics specification [ RDF-Semantics ] defines 4 notions of entailment for RDF graphs. AtThroughout this stage it has not yet been decided which of these notions are of interest in RIF. Therefore, we specifydocument the interaction betweenfollowing conventions are used when
writing RIF and RDF for all 4 notions. EDITOR'S NOTE: Currently, this document only defines how combinations of RIF rule setsstatements in examples and definitions.
The RDF semantics specification (RDF-Semantics) defines four notions of entailment for
RDF graphs. At this stage it has not been decided which of these
notions are of interest in RIF. The OWL semantics specification
(OWL-Semantics) defines
two notions of entailment for OWL ontologies, namely OWL Lite/DL
and OWL Full; both notions are of interest in RIF. This document
specifies the interaction between RIF and RDF/OWL for all six
notions.
EDITOR'S NOTE: Currently, this document only defines how
combinations of RIF rulesets and RDF/OWL should be interpreted; it
does not suggest how references to RDF graphs and OWL ontologies
are specified in RIF, nor does it specify which of the RDFRDF/OWL
entailment regimes (simple, RDF, RDFS, or D)D, OWL DL, OWL Full) should
be used. Finally, there are two notions of interoperation with OWL
DL: one that does not consider annotation properties, and one that
does it is an open issue whether this distinction should be
reflected in the syntax. Possible ways to refer to RDF graphs and
RDFS/OWL ontologies include annotations in RIF rule setsrulesets and
extensions of the syntax of RIF. Note that no agreement has yet
been reached on this issue, and that especially the issue of the
specification of entailment regimes is controversial (see
http://lists.w3.org/Archives/Public/public-rif-wg/2007Jul/0030.html
and the ensuing thread). See the Annotations
page for a proposal for extending RIF with annotations.
The #Appendix: Embedding RDF CombinationsEmbeddings (Informative) describes how reasoning
with combinations of RIF rules with RDF and a subset of OWL DL can
be reduced to reasoning with RIF rule sets,rulesets, which can be seen as a
guide to describing how ana RIF processor could be turned into an
RDF-awareRDF/OWL-aware RIF processor. This reduction can be seen as a guide
for interchange partners whichthat do not have RDF-aware rule systems,
but stillwant to be able to process RIF rules whichthat refer to RDF graphs.
In terms of the scenario above:aforementioned scenario: if the interchange partner
B does not have an RDF-awareRDF/OWL-aware rule system, but B
can process RIF rules, then the appendix explains how theB's
rule system could be used for processing combinations. EDITOR'S NOTE: The future status of the appendix with the embedding is uncertain . The appendix is not about interchange, but rather about possible implementation, so it can be argued that it should not be included in this document. On the other hand, many think the appendix is useful. If we decide not to include it in this document, we might consider publishing it as a separate note (not recommendation-track document).RIF-RDF.
When speaking about RDF compatibility in RIF, we speak about RIF-RDF combinations, which are combinations of RIF rule sets and sets of RDF graphs.This section specifies how, in suchhow RIF ruleset interacts with a combination, the ruleset and theof
RDF graphs interact.in a RIF-RDF combinations. In other words, how rules can
"access""access" data in the RDF graphs and how additional conclusions whichthat
may be drawn from the RIF rules are reflected in the RDF
graphs.
There is a correspondence between constant symbols in RIF
rule setsrulesets and names in RDF graphs. The following table explains the
correspondences of symbols.
RDF Symbol | Example | RIF Symbol | Example |
---|---|---|---|
Absolute IRI | |
Absolute IRI | |
Plain literal without |
|
String in the symbol space xsd:string | |
Plain literal with |
|
String plus language tag in the symbol space rif:text | |
Literal with |
|
Symbol in |
|
There is, furthermore, a correspondence between statements in
RDF graphs and certain kinds of formulas in RIF. Namely, there is a
correspondence between RDF triples of the form s p o .and
RIF frame formulas of the form s'[p' ->-> o'], where
s', p', and o' are RIF symbols
corresponding to the RDF symbols s, p, and
o, respectively. This means that whenever a triple s p
o .is satisfied, the corresponding RIF frame formula s'[p'
->-> o'] is satisfied, and vice versa.
Consider, for example, a combination of an RDF graph whichthat
contains the triples
johnbrotherOfjack.jackparentOfmaryex:john ex:brotherOf ex:jack . ex:jack ex:parentOf ex:mary .
saying that johnex:john is a brother of jackex:jack
and jackex:jack is a parent of maryex:mary, and ana RIF
rule set whichruleset that contains the rule
Forall ?x, ?y, ?z(?x["uncleOf"^^rif:iri->(?x[ex:uncleOf -> ?z] :-And(?x["brotherOf"^^rif:iri->And(?x[ex:brotherOf -> ?y]?y["parentOf"^^rif:iri->?y[ex:parentOf -> ?z]))
which says that whenever some x is a brother of some
y and y is a parent of some z, then
x is an uncle of z. From this combination we can derivethe RIF
frame formula "john"^^rif:iri["uncleOf"^^rif:iri -> "mary"^^rif:iri]:john[:uncleOf -> :mary], as well as
the RDF triple john uncleOf marry .:john :uncleOf :mary, can be
derived.
Note that blank nodes cannot be referenced directly from RIF
rules, since blank nodes are local to a specific RDF graph.
Variables in RIF rules do, however, range over objects denoted by
blank nodes. So, it is possible to "access""access" an object denoted by a
blank node from ana RIF rule using a variable in a rule.
Typed literals in RDF may be ill-typed, which means that
the literal string is not part of the lexical space of the datatype
under consideration. Examples of such ill-typed literals are
"abc"^^xsd:integer"abc"^^xsd:integer, "2"^^xsd:boolean"2"^^xsd:boolean, and
"<non-valid-XML"^^rdf:XMLLiteral"<non-valid-XML"^^rdf:XMLLiteral. Ill-typed literals
are not expected to be used very often. However, as the RDF
recommendation (RDF-Concepts) allows creating RDF graphs with ill-typed
literals, their occurrence cannot be completely ruled out.
Rules whichthat include ill-typed symbols are not well-formedlegal RIF rules, so
there are no RIF symbols whichthat correspond to ill-typed literals. However,As
with blank nodes, variables may quantifydo range over objects denoted by such
literals. The following example illustrates the interaction between
RDF and RIF in the face of ill-typed literals and blank nodes.
Consider a combination of an RDF graph whichthat contains the
triple
_:xhasName"a"^^xsd:integerex:hasName "a"^^xsd:integer .
saying that there is some blank node whichthat has a name, which is
an ill-typed literal, and ana RIF rule set whichruleset that contains the rules
Forall ?x, ?y ( ?x[rdf:type->"nameBearer"^^rif:iri]-> ex:nameBearer] :-?x["hasName"^^rif:iri->?x[ex:hasName -> ?y] ) Forall ?x, ?y ("http://a"^^rif:iri["http://p"^^rif:iri->"http://a"^^rif:iri["http://p"^^rif:iri -> ?y] :-?x["hasName"^^rif:iri->?x[ex:hasName -> ?y] )
which say that whenever there is a some x whichthat has some
name y, then x is of type nameBearerex:nameBearer
and http://a has a property http://p with value
y.
From this combination we can derivethe following RIF condition formulasformula can be
derived:
Exists ?z ( And( ?z[rdf:type->"nameBearer"^^rif:iri])Exists?z("http://a"^^rif:iri["http://p"^^rif:iri->-> ex:nameBearer] "http://a"^^rif:iri["http://p"^^rif:iri -> ?z])aswell))
as can the following RDF triplestriples:
_:y rdf:typenameBearerex:nameBearer .<http://a><http://p>"a"^^xsd:integer<http://a> <http://p> "a"^^xsd:integer .
However, " http://a "^^rif:iri[" http://p "^^rif:iri -> "a"^^xsd:integer]"http://a"^^rif:iri["http://p"^^rif:iri ->
"a"^^xsd:integer] cannot be derived, because it is not a
well-formed RIF formula, due to the fact that "a""a" is not
an integer; it is not in the lexical space of the datatype
xsd:integer.
This remainder of this section formally defines combinations of RIF
rules with RDF graphs and the semantics of such combinations. Combinations are pairsA
combination consists of a RIF rule setsruleset and setsa set of RDF graphs. The
semantics of combinations is defined in terms of combined models,
which are pairs of RIF and RDF interpretations. The interaction
between the two interpretations is defined through a number of
conditions. Entailment is defined as model inclusion, as usual.
This section first reviews the definitions of RDF vocabularies
and RDF graphs, after which definitions related to datatypes and
ill-typed literals are reviewed. Finally, RIF-RDF combinationsRIF-RDF-combinations are
formally defined.
An RDF vocabulary V consists of the following sets of names:
The syntax of the names in these sets is defined in RDF Concepts
and Abstract Syntax [(RDF-Concepts ].). Besides these names, there is an infinite set
of
blank nodes, which is disjoint from the sets of literals and
IRIs.
DEFINITION: Given an RDF vocabulary V, a
generalized RDF graphtriple of V is a setstatement of
generalized RDF triplesthe form s p o ., where s, p and
o are names in V or blank nodes.
DEFINITION: Given an RDF vocabulary V, a generalized RDF graph is a set of generalized RDF triples of V.
(See the [(End
note on generalized RDF graphs ])))
Even though RDF allows the use of arbitrary datatype IRIs in
typed literals, not all such datatype IRIs are recognized in the
semantics. In fact, simple entailment does not recognize any
datatype and RDF and RDFS entailment recognize only the datatype
rdf:XMLLiteral. Furthermore, RDF allows expressing typed
literals for which the literal string is not in the lexical space
of the datatype; such literals are called ill-typed
literals. RIF, in contrast, does not allow ill-typed literals
in the syntax. To facilitate discussing datatypes, and specifically
datatypes supported in specific contexts (required for
D-entailment), we usethe notion of datatype maps [(RDF-Semantics ].) is used.
A datatype
map is a partial mapping from IRIs to datatypes.datatypes.
RDFS, specifically D-entailment, allows the use of arbitrary
datatype maps, as long as the rdf:XMLLiteral datatype is
considered.included in the map. RIF BLD additionally requires the following
datatypes to be considered: xsd:long ,included: xsd:string,
xsd:integer ,xsd:decimal, xsd:time, xsd:date,
xsd:dateTime, and rif:text; we callthese datatypes are
the RIF-required
datatypes. We define the notion ofA conforming datatype map asis a datatype map
whichthat recognizes at least the RIF-required datatypes.
DEFINITION: A datatype
map D is a conforming datatype
map if it satisfies the following conditions 1.conditions:
The notions of well- and ill-typed literals, whichliterals loosely correspond
to the notions of well-formedlegal and ill-formedillegal symbols in RIF.RIF:
DEFINITION: Given a conforming datatype map D, a typed literal (s, d) is a well-typed literal if
Otherwise (s, d) is an ill-typed literal.
We now formally define combinations. DEFINITION: AnA RIF-RDF combination consists of a RIF ruleset and zero or more
RDF graphs. Formally:
DEFINITION: A RIF-RDF-combination
is a pair < R,S >,>, where R is a Rule setRIF
ruleset and S is a set of generalized RDF graphs of
a vocabulary V.
When clear from the context, RIF-RDF combinationsRIF-RDF-combinations are referred
to simply as combinations.
The semantics of RIF rule setsrulesets and RDF graphs are defined in
terms of model theories. The semantics of RIF-RDF combinationsRIF-RDF-combinations is
defined through a combination of the twoRIF and RDF model theories,
using a notion of common models. These models are then used
to define satisfiability and entailment in the usual way. Combined
entailment extends both entailment in RIF and entailment in
RDF.
The RDF Semantics document [(RDF-Semantics ]) defines 4 (normative)four normative kinds of
interpretations, as well as corresponding notions of satisfiability
and entailment:
This distinction isThose four types of interpretations are reflected in the
definitions of satisfaction and entailment in this section.
We defineThis section defines the notion of
common interpretationcommon-rif-rdf-interpretation, which is an interpretation of
an RIF-RDF combination.a RIF-RDF-combination. This common interpretationcommon-rif-rdf-interpretation is the
basis for the definitions of satisfaction and entailment in the
following sections.
The correspondence between RIF semantic
structures (interpretations) and RDF interpretations is
defined through a number of conditions whichthat ensure the
correspondence in the interpretation of names (i.e., IRIs and
literals) and formulas, i.e., the correspondence between RDF
triples of the form s p o .and RIF frames of the form
s'[p' ->-> o'], where s', p', and
o' are RIF symbols corresponding to the RDF symbols
s, p, and o, respectively. We first reviewrespectively (cf. Table 1).
The notions of RDF interpretationsinterpretation and RIF semantic structures, after which we define common interpretations. 2.2.1.1 RDF and RIF Interpretationsstructure
(interpretation) are briefly reviewed below.
As defined in [(RDF-Semantics ],), a simple
interpretation of a vocabulary V is a tuple
I=< IR, IP, IEXT, IS, IL, LV >,>, where
Rdf-, rdfs-, and D-interpretations are simple interpretations
whichthat satisfy certain conditions:
As defined in [(RIF-BLD ],), a
semantic structure is a tuple of the form
I = <TV, DTS,
D, Dind,
Dfunc, IC,
IV, IF,
Iframe, ISF,
Isub, Iisa,
I=, Iexternal,
Itruth >. We restrict our attention here to>. The specification of RIF-RDF
compatibility is only concerned with DTS,
D, IC,
IV, Iframe,
Isub, Iisa, and
I slottruth. The other mappings whichthat are parts
of a semantic structure are not used in the definition of
combinations.
DEFINITION: A common-rif-rdf-interpretation
is a pair (I, I), where I =
<TV, DTS, D,
Dind, Dfunc,
IC, IV,
IF, Iframe,
ISF, Isub,
Iisa, I=,
Iexternal,
Itruth >> is ana RIF semantic
structure and I=<IR, IP, IEXT, IS, IL, LV>LV> is an RDF interpretation of a
vocabulary V, such that the following conditions hold 1. IR is a subset ofhold:
Condition 1 ensures that all resources in an RDF interpretation correspond to elements in the RIF domain. Condition 2 ensures that the set of properties at least includes all elements which are used as properties in the RIF domain. Condition 3 ensures thatthe combination of resources and
properties corresponds exactly to the RIF domain; note that if I is
an rdf-, rdfs-, or D-interpretation, IP is a subset of IR, and thus
IR=D. Condition 42 ensures that the set of RDF
properties at least includes all elements that are used as
properties in frames in the RIF domain. Condition 3 ensures that
all concrete values in D are included in LV.
Condition 54 ensures that RDF triples are interpreted in the same
way as frame formulas. Condition 65 ensures that IRIs are
interpreted in the same way. Finally,Condition 76 ensures that typed
literals are interpreted in the same way. Note that no
correspondences are defined for the mapping of names in RDF whichthat
are not symbols of RIF, e.g., ill-typed literals and RDF URI
references whichthat are not absolute IRIs. Condition 8 the7 ensures that
typing in RDF and typing in RIF correspond, i.e.i.e., a rdf:type
b is true iff a # b is true. Finally, condition 9 the8
ensures that whenever ana RIF subclass statement holds, the
corresponding RDF subclass statement holds as well, i.e., a
rdfs:subClassOf b is true if a ## b is true.
One consequence of conditions 65 and 76 is that IRIs of the form
http://iri and typed literals of the form
" http://iri "^^rif:iri which"http://iri"^^rif:iri that occur in an RDF graph are
treated the same in RIF-RDF combinations,RIF-RDF-combinations, even if the RIF componentRuleset
is empty. For example, consider an RIF-RDFthe combination withof an empty rule setruleset
and an RDF graph whichthat contains the triple
<http://a><http://p>"http://b"^^rif:iri<http://a> <http://p> "http://b"^^rif:iri .
This combination allows to derive,the derivation of, among other things,
the following triples: < http://a > < http://p > < http://b > . < http://a > " http://p "^^rif:iri " http://b "^^rif:iri . " http://a "^^rif:iri < http://p > " http://b "^^rif:iritriple:
<http://a> <http://p> <http://b> .
as well as the following frame formula:
"http://a"^^rif:iri["http://p"^^rif:iri->"http://b"^^rif:iri]"http://a"^^rif:iri ["http://p"^^rif:iri -> "http://b"^^rif:iri]
We now defineThe notion of satisfiability for common interpretations, i.e.,refers to the conditions under
which a common interpretationcommon-rif-rdf-interpretation (I, I) is a
model of a combination < R, S >. We define notions>. The notion of
satisfiability is defined for all 4four entailment regimes of RDF
(simple, RDF, RDFS, and D). The definitions are all analogous.
Intuitively, a common interpretationcommon-rif-rdf-interpretation (I, I)
satisfies a combination < R, S >> if
I satisfiesis a model of R and I satisfies S.
Formally:
DEFINITION: A common interpretationcommon-rif-rdf-interpretation (I, I)
simple-satisfies an RIF-RDF combinationsatisfies a
RIF-RDF-combination
C=< R, S >> if I satisfiesis a model of
R and I satisfies every RDF
graph S in S; in this case (I, I) is
called a simple
model, or model, of C, and C is
satisfiable. (I, I) satisfies a
generalized RDF
graph S if I satisfies S. (I, I)
satisfies a closed RIFRIF-BLD condition formulaφ if
TValI truth (φ)=((φ)=t.
Notice that not every combination is satisfiable. In fact, not
every RIF rule setruleset has a model. For example, the rule setruleset consisting
of the rule
Forall("1"^^xsd:integer="2"^^xsd:integer)("1"^^xsd:integer="2"^^xsd:integer)
does not have a model, since the symbols
"1"^^xsd:integer"1"^^xsd:integer and "2"^^xsd:integer"2"^^xsd:integer are mapped
to the (distinct) numbers 1 and 2, respectively, in every semantic
structure.
Rdf-, rdfs-, and D-satisfiability are defined through additional restrictions on I:
DEFINITION: A model (I, I) of a combination C rdf-satisfiesis an
rdf-model of C if I
is an rdf-interpretation;
in this case ( I , I) is called an rdf-model of C, andC is rdf-satisfiable.
DEFINITION: A model (I, I) of a combination C rdfs-satisfiesis an
rdfs-model of C if I
is an rdfs-interpretation;
in this case ( I , I) is called an rdfs-model of C, andC is rdfs-satisfiable.
DEFINITION: Given a conforming datatype map
D, a model
(I, I) of a combination C D-satisfiesis a D-model of C if I is a D-interpretation; in
this case ( I , I) is called a D-model of C, andC is D-satisfiable.
Using the notions of models defined above, entailment is defined in the usual way, i.e., through inclusion of sets of models.
DEFINITION: Given a conforming datatype map
D, an RIF-RDF combinationa RIF-RDF-combination C D-entails a generalized RDF graph
S if every D-model of C
satisfies S.
Likewise, C D-entails a closed RIFRIF-BLD
condition formulaφ if every D-model of C satisfies φ.
The other notions of entailment are defined analogously:
DEFINITION: A combination C simple-entails S (resp., φ) if every simple model of C satisfies S (resp., φ).
DEFINITION: A combination C rdf-entails S (resp., φ) if every rdf-model of C satisfies S (resp., φ).
DEFINITION: A combination C rdfs-entails S (resp., φ) if every rdfs-model of C satisfies S (resp., φ).
Two kinds of combinations of RIF rules with OWL ontologies are considered. The combination of RIF rules withThe Full species ofsyntax for exchanging OWL ontologies is a straightforward extension of RIF-RDF compatibility (see the definition below ), in whichbased on RDF triples correspond to RIF frame formulas. The combinationgraphs.
Therefore, RIF-OWL-combinations are combinations of RIF rules with the DLrulesets
and Lite speciessets of OWL is slightly different; OWL classes and properties correspondRDF graphs, analogous to RIF-RDF-combinations. This
section specifies how RIF unary and binary predicates, respectively. The discrepancy between the two kinds of combinations is overcome by interpreting frame formulas as unary and binary predicatesrulesets and imposing certain restrictions on the use of variables in the rules. 3.1OWL Speciesontologies interoperate
in such combinations.
OWL [(OWL-Reference ])
specifies three increasingly expressive species, namely Lite, DL,
and Full. OWL
Lite is a syntactic subset of OWL DL,
but the semantics is the same [(OWL-Semantics ].). Since every OWL Lite ontology is an OWL DL
ontology, the Lite species is not explicitlyconsidered separately in the remainder.this
document.
Syntactically speaking, OWL DL
is a subset of OWL Full ., but the
semantics of the DL and Full species are different, though [different (OWL-Semantics ].). While OWL DL has
an abstract
syntax with a direct
model-theoretic semantics, the semantics
of OWL Full is an extension of the semantics of RDFS, and is
defined on the RDF syntax of OWL. Consequently, the OWL Full
semantics does not extend the OWL DL semantics; however,
everyall derivations sanctioned by the OWL DL entailment is ansemantics are sanctioned
by the OWL Full entailmentsemantics.
Finally, the
OWL DL RDF syntax, which is based on the OWL
abstract syntax, does not extend the RDF syntax, but rather
restricts it: every OWL DL ontology is an RDF graph, but not every
RDF graph is an OWL DL ontology. OWL Full and RDF have the same
syntax: every RDF graph is an OWL Full ontology and vice versa.
Note thatThis syntactical difference is reflected in the abstract syntax form of OWL DL allows so-called punning (this is not allowed in the RDF syntax), i.e., the same IRI may be used in an individual position, a property position, and a class position; the interpretationdefinition of
the IRI depends on its context. SinceRIF-OWL compatibility: combinations of RIF andwith OWL DL are based on
the OWL
abstract syntax of OWL DL, punning may also be used in these combinations. This paves the way towards combination with OWL 1.1, which is envisioned to allow punning in all its syntaxes. 3.2 Syntax of RIF-OWLwhereas combinations Sincewith OWL Full are based
on the RDF graphs andsyntax.
Since the OWL Full ontologies cannot be distinguished, we usesyntax is the notion of RIF-RDF combinations forsame as the RDF syntax of combinations of RIF rule sets withand the OWL
Full ontologies. For the combinationsemantics is an extension of RIF rule sets with OWL DL ontologies we definethe notionRDF semantics, the definition
of RIF-OWL Full compatibility is a straightforward extension of
RIF-RDF compatibility. Defining RIF-OWL DL combinations based oncompatibility in the
abstract syntaxsame way would entail losing certain semantic properties of OWL DL.
We need to furthermore impose certain restrictions on the syntaxOne of the rules. Specifically, we can only allow constant symbolsmain reasons for this is the difference in classthe way
classes and property positions. DEFINITION: An RIF rule set R is a DL Rule set if for every frame formula a [ b -> c ]properties are interpreted in every ruleOWL Full and OWL DL. In
the Full species, classes and properties are both interpreted as
objects in the domain of interpretation, which are then associated
with subsets of R it holds that b is a constantand if b =binary relations over the domain of
interpretation using rdf:type , then c is a constant. DEFINITION: An RIF-OWL DL combination is a pair < R , O >, where R is a DL Rule setand O is a set of OWL DL ontologiesthe extension function
IEXT, as in RDF. In abstract syntax form of a vocabulary V . When clear fromthe context, RIF-OWLDL combinationsspecies, classes and properties are
referred to simplydirectly interpreted as combinations . 3.3 Semanticssubsets of RIF-OWL Combinationsand binary relations over the
semantics of RIF-OWL Full combinationsdomain. The latter is a straightforward extension of the #Semanticskey property of RIF-RDF Combinations . TheDescription Logic semantics
that enables the use of Description Logic reasoning techniques for
processing OWL DL descriptions. Defining RIF-OWL DL combinations cannot straightforwardly extends the semanticscompatibility
as an extension of RIF RDF combinations, becauseRIF-RDF compatibility would define a
correspondence between OWL DL does not extendstatements and RIF frame formulas.
Since RIF frame formulas are interpreted using an extension
function, the RDF semantics.same way as in order to keep the syntax ofRDF, defining the rules uniformcorrespondence
between RIF-Fullthem and RIF-OWLOWL DL combinations,statements would change the semantics of
OWL statements, even if the RIF frame formulasruleset is slightly altered in RIF-OWL DL combinations. 3.3.1empty. Consider, for
example, an OWL FullDL ontology with a class membership statement
a rdf:type C .
This statement says that the semantics of RIF-OWL Full combinationsset denoted by C contains
at least one element that is denoted by a straightforward extension of. The
semantics of RIF-RDF combinations. Itcorresponding RIF frame formula is
basedona[rdf:type -> C]
The same notion of common interpretationsterms a, rdf:type, but defines additional notions of satisfiabilityand entailment. DEFINITION: Given a conforming datatype map D, a common interpretation ( I , I) OWL Full satisfies an RIF-RDF combination C=< R , S > if I satisfies R , I is an OWL Full interpretation , and I satisfies every RDF graph S in S ;C are all
interpreted as elements in this case ( I , I) is called an OWL Full modelthe individual domain, and the pair of
C,elements denoted by a and C is OWL Full satisfiablein the extension
of the element denoted by rdf:type.
DEFINITION: Given a conforming datatype map D,This semantic discrepancy has practical implications in terms of
entailments. Consider, for example, an RIF-RDF combination COWL Full entailsDL ontology with two
class membership statements
ageneralizedRDFgraphSifeveryOWLFullmodelofrdf:type CsatisfiesS.Likewise,COWLFullentailsD rdf:type owl:Class .
and a closedRIF condition formula φ ifruleset
Forall ?x ?y ?x=?y
which says that every OWL Full model of C satisfies φ. 3.3.2 OWL DL The semantics of RIF-OWL DL combinationselement is similar in spirit tothe semantics of RIF-RDF combinations. We define a notion of common interpretations, which are pairs of RIF andsame as every other element
(note that such statements can also be written in OWL DL interpretations,using
owl:Thing and define a numberowl:hasValue). From the naïve
combination of conditions which relate these interpretations. In contrast to RIF-RDF combinations,the conditions below definetwo one can derive C=D, and indeed
acorrespondencebetweenrdf:type D .
This derivation is not sanctioned by the interpretation ofOWL DL classes and properties and RIF unary and binary predicates. Itsemantics,
because even if every element is nowthe case that elementarysame as every other element,
the class and property statements in OWL DL ofD might be interpreted as the formsempty set.
A and P correspondRIF-OWL combination that is faithful to the OWL DL semantics
requires interpreting classes and properties as sets and binary
relations, respectively, suggesting that correspondence could be
defined with unary and binary predicates expressions inpredicates. It is, however, also
desirable that there be uniform syntax for the RIF component of
the forms A(?x) and P(?x,?y) , whereas elementary statements inboth OWL Full,DL and RDF/OWL Full combinations, because one may not know
at time of writing the rules which are triples, correspond to frame formulas in RIF, e.g., a class membershiptype of inference will be used.
Consider, for example, an RDF graph S with the following
statement
xa rdf:type C .
and a correspondsRIF ruleset with the rule
Forall ?x ?x[rdf:type -> D] :- ?x[rdf:type -> C]
The combination of the two, according to x[rdf:type -> A]the specification of
[#RDF_Compatibility], allows deriving
a rdf:type D .
Therefore, rules which essentially expressNow, the same thing will look quite different, depending on whether they are used inRDF graph S is also an OWL DL and OWL Full ontologies. For example, in anontology. Therefore, one
would expect the triple to be derived by RIF-OWL DL combination,combinations as
well.
To ensure that the uncle rule looks something like: hasUncle(?x,?y) :- And(hasParent(?x,?y) hasBrother(?y,?z)) whereas, in anRIF-OWL Full combination, the rule will look something like: ?x[hasUncle -> ?y] :- And(?x[hasParent -> ?y] ?y[hasBrother -> ?z])DL combination is faithful to overcome this problem we define a slightly modifiedthe OWL DL
semantics for RIF rulesand to enable using the use ofsame, or similar, rules with both
OWL DL and RDF/OWL Full, the latter kindinterpretation of rulesframe formulas
s[p -> o] in the RIF-OWL DL combinations.combinations is slightly
different from their interpretation in RIF BLD and syntactical
restrictions are imposed on the modified semantics essentially corresponds to a rewriting of atomic formulasuse of variables and function terms
and frame formulas.
Note that the abstract syntax form x[rdf:type -> y] to y(x)of OWL DL allows so-called
punning (this is not allowed in the RDF syntax), i.e., the
same IRI may be used in an individual position, a property
position, and x[p -> y] to p(x, y) . 3.3.2.1 Modified Semantics for RIF Frame Formulas We definea new truth valuation function forclass position; the interpretation of the IRI
depends on its context. Since combinations of RIF formulas,and OWL DL are
based on the abstract syntax of OWL DL, punning may also be used in
these combinations. This paves the way towards combination with
OWL 1.1, which is envisioned to
allow punning in all its syntaxes.
EDITOR'S NOTE: The semantics of RIF-OWL DL combinations is similar in spirit to the Semantic Web Rule Language proposal. However, a reference to SWRL from the above text does not seem appropriate.
Since RDF graphs and OWL Full ontologies cannot be
distinguished, the syntax of RIF-OWL Full combinations is the same
as the truth valuation function definedsyntax of RIF-RDF-combinations.
The syntax of OWL ontologies in RIF-BLD , withRIF-OWL DL combinations is
specified by the exceptionabstract syntax of OWL DL. Certain restrictions
are imposed on the syntax of the RIF rules in combinations with OWL
DL. Specifically, the only terms allowed in class and property
positions in frame formulas.formulas are constant symbols.
DEFINITION: Given anA RIF-BLD
condition φ is a RIF
semantic structure IDL-condition if for every frame formula a[b
-> c] in φ it holds that b is a constant and if
b = < TV , DTS , Drdf:type, Ithen c , I V , I F , I frame , I SF , I sub , I isa , I = , I Truth >, the truth valuation function I T-DLis obtained by modifying the truth valuation ofa constant.
DEFINITION: A RIF-BLD ruleset R is a DL-Ruleset if for every frame
formulas in I Truthformula a[b -> c] in the following way: I T-DL ( t [ rdf:type -> A ] ) = Ievery rule of R (it holds
that b is a )( t )constant and I T-DL ( t 1 [ P -> t 2 ] )if b =
I R ( P )( t 1rdf:type, t 2 ).then c is a constant.
DEFINITION: We say that I DL satisfiesA rule Q then :- ifRIF-OWL-DL-combination
is a pair < R,O>, where QR is a quantification prefix for allDL-Ruleset and O is a set of
OWL DL ontologies
in abstract syntax form of a vocabulary V.
When clear from the variablescontext, RIF-OWL-DL-combinations are
referred to simply as combinations.
In the rule, if I * T-DL (then) ≥ I * T-DL (if) for every I * that agrees with I everywhere except possiblyliterature, several restrictions on somethe use of variables
mentionedin Q . I is a DL modelcombinations of rules and Description Logics have been
identified (Motik05, Rosati06) for the purpose of decidable
reasoning. These restrictions are specified for RIF-OWL-DL
combinations.
Given a ruleset R if it DL satisfies every rule in the set. 3.3.2.2 Semanticsof RIF-OWLOWL DL Combinations DEFINITION: Givenontologies in abstract syntax form
O, a conforming datatype map D,variable ?x in a common DL interpretationRIF rule Q
then :- if is a pair ( IDL-safe if it occurs
in an atomic formula in if that is not of the form s[P
-> o] or s[rdf:type -> A], I),where I = < TV , DTS , D , I C , I V , I F , I frame , I SF , I sub , I isaP or
A, I =respectively, occurs in one of the ontologies in
O. A RIF rule Q then :- if is
DL-safe, I Truth >given O if every variable that occurs
in then :- if is anDL-safe. A RIF semantic structurerule Q
then :- if is weakly DL-safe,
given O if every variable that occurs in then is
DL-safe and I=<R, EC, ER, L, S, LV>every variable in if that is an abstract OWL interpretation with respect to Dnot DL-safe occurs
only in atomic formulas in if that are of the form s[P
-> o] or s[rdf:type -> A], where P or
A vocabulary V, such thatrespectively, occurs in one of the following conditions hold 1. R= D ; 2. LVontologies in
O.
EDITOR'S NOTE: it is not strictly necessary to disallow
disjunctions in the definition, but it would make the definition a
subsetlot more complex. It would require defining the disjunctive normal
form of Ra condition formula and containsdefine safeness with respect to
each disjunct. Given that the value spaces of all data types in D; 3. EC( u ) = set of all objects k in R suchsafeness restriction is meant for
implementation purposes, and that Iconverting rules to disjunctive
normal form is extremely expensive, it is probably a reasonable
restriction to disallow disjunction.
DEFINITION: A RIF-OWL-DL-combination < R ( "u"^^rif:iri )( k ) = t (true), for,O> is
DL-safe if every IRI urule in V ; 4. ER( u ) = set of all tuples ( k , l ) such that IR ( "u"^^rif:iri )( kis DL-safe, given
O. A RIF-OWL-DL-combination < R, l ) = t (true), forO> is
weakly DL-safe if every data valued and individual valued property identifier u in V ; 5. L(( s , d )) = I C ( "s"^^d ) for every well-typed literal ( s , d ) in V ; 6. S( i ) = I C ( "i"^^rif:iri ) for every IRI irule in VR is weakly
DL-safe, given O.
Condition 1 ensuresEDITOR'S NOTE: Do we want additional safeness
restrictions to ensure that variables do not cross the
domainsabstract-concrete domain boundary?
The same. Condition 2 ensures thatsemantics of RIF-OWL Full combinations is a straightforward
extension of the set#Semantics of literal values includesRIF-RDF Combinations.
The value spacessemantics of all considered datatypes. Condition 3 ensures thatRIF-OWL-DL-combinations cannot
straightforwardly extend the interpretation (extension)semantics of anRIF RDF combinations,
because OWL DL class u correspondsdoes not extend the RDF semantics. In order to keep
the interpretationsyntax of the unary predicate with the same name in RIF. Condition 4 ensures thatrules uniform between RIF-OWL Full and
RIF-OWL-DL-combinations, the interpretation (extension)semantics of RIF frame formulas is
slightly altered in RIF-OWL-DL-combinations.
A D-interpretation
I is an OWL DL object or datatype property u corresponds to theFull interpretation ofif it interprets the
binary predicates withOWL vocabulary and it satisfies the same nameconditions in RIF. Condition 5 ensures that typed literals ofthe form ( s , d )sections
5.2 and
5.3 in (OWL
DL are interpreted inSemantics).
The same way as constantssemantics of RIF-OWL Full combinations is a straightforward
extension of the form "s"^^d in RIF. Finally, condition 6 ensures that individual identifiers in the OWL ontologies and the RIF rule sets are interpreted insemantics of RIF-RDF-combinations. It is based on
the same way. Using the definitionnotion of common interpretation, satisfaction, models,common-interpretations, but defines additional notions
of satisfiability and entailment are defined in the usual way:entailment.
DEFINITION: Given a conforming datatype map
D, a common DL interpretationcommon-rif-rdf-interpretation (I, I) OWL DL satisfiesis an
RIF-OWL DL combinationOWL-Full-model
of a RIF-RDF-combination C=< R, O >S > if
I DL satisfiesis a model of R, I is an OWL Full
interpretation, and I satisfies every
OWL DL ontology in abstract syntax form ORDF graph S in OS; in this case ( I , I) is called an OWL DL model of C, andC is OWL DL satisfiable . ( I , I) satisfies an OWL DL ontology in abstract syntax form O if I satisfies O . ( I , I) satisfies a closed RIF condition formula φ if I T-DL (φ)= tOWL-Full-satisfiable.
DEFINITION: Given a conforming datatype map
D, an RIF-OWL DL combinationa RIF-RDF-combination C OWL DL entails an OWL DL ontology in abstract syntax form OOWL-Full-entails a
generalized RDF graph S if every OWL DL modelOWL-Full-model of C satisfies S. Likewise,
C OWL DL entailsOWL-Full-entails a closed RIFRIF-BLD
condition formulaφ if every OWL DL modelOWL-Full-model of C satisfies φ.
The above definitionsemantics of RIF-OWL DL compatibility does not consider ontology and annotation properties,RIF-OWL-DL-combinations is similar in contrastspirit to
the definition of compatibilitysemantics of RIF with OWL Full, whereRIF-RDF-combinations. Analogous to a
common-rif-rdf-interpretation, there is no clear distinction between annotationthe notion of
common-rif-dl-interpretations, which are pairs of RIF and ontology propertiesOWL DL
interpretations, and other kindswhich define a number of properties. Therefore, it is not possibleconditions that
relate these interpretations to "access" or useeach other. In contrast to
RIF-RDF-combinations, the valuesconditions below define a correspondence
between the interpretation of theseOWL DL classes and properties inand RIF
unary and binary predicates.
The modification of the semantics of RIF rules. This limitationframe formulas is
overcome inachieved by modifying the following definition. It is envisioned that the user will choose whether annotationmapping function for frame formulas
(Iframe), and ontology propertiesleaving the RIF BLD
semantics (RIF-BLD) otherwise
unchanged.
Namely, frame formulas of the form s[rdf:type -> o]
are to be considered. It is noted that itinterpreted as membership of s in the set denoted by
o and frame formulas of the form s[p -> o],
where p is envisioned that OWL 1.1 willnot define a semantics for annotation and ontology properties; therefore,rdf:type, as membership of the
below definition cannot be extended topair (s, o) in the case of OWL 1.1.binary relation denoted by
p.
DEFINITION: GivenA conforming datatype map D,RIF
DL-semantic structure is a common DL interpretation (tuple I =
<TV, I)DTS, D,
Dind, Dfunc,
IC, IV,
IF, Iframe',
ISF, Isub,
Iisa, I=,
Iexternal,
Itruth>, where
Iframe' is a common DL annotation interpretation if the following condition holds 7. ER( u ) = setmapping from
Dind to total functions of all tuplesthe form
SetOfFiniteFrame'Bags( k , lD × D) →
D, such that I Rfor each pair ( "u"^^rif:iri )( k , la, b) = t (true), for every IRI uin
V . Condition 7 ensuresSetOfFiniteFrame'Bags(D × D)
holds that the interpretation of all properties (also annotation and ontology properties)if
a≠IC(rdf:type), then
b in Dind; all other elements of
the OWL DL ontologies corresponds with their interpretationstructure are defined as in theRIF rules. DEFINITION: Given a conforming datatype map D,semantic
structures.
We define I(o[a1->v1
... a common DL annotation interpretationk->vk]) =
Iframe(I , I) OWL DL annotation satisfies an RIF-OWL DL combination C=< R ,(o > if))({<I satisfies R and(a1),I satisfies every OWL DL ontology in abstract syntax form O in O ; in this case(v1)>,
...,
<I(an),I(vn)>}).
The truth valuation function TValI , I) is called an OWL DL annotation model of C, and Cis OWL DL annotation satisfiablethen
defined as in RIF BLD.
DEFINITION: GivenA conforming datatype map D, an RIF-RDF combination C OWL DL annotation entails an OWL DL ontology and abstract syntax form O if every OWL DL annotationRIF
DL-semantic structure I is a model of C satisfies O . Likewise, C OWL DL annotation entailsa closed RIF condition formula φDL-Ruleset R if
every OWL DL annotation model of C satisfies φ. We illustrate the difference between the two kindsTValI(R)=t.
As defined in abstract syntax form Ontology (ex:myOntology Annotation(dc:title "Example ontology")) which defines(OWL-Semantics), an ontologyabstract OWL
interpretation with respect to a single annotation (title). Consider alsodatatype map D, with
vocabulary V is a ruletuple I=< R, EC, ER, L, S, LV >,
where
The OWL DL annotation entailssemantics imposes a number of further
restrictions on the RIF condition formula ex:myOntology[ex:hasTitle -> "Example ontology"^^xsd:string] ;mapping functions as well as the combination does not OWL DL entailset of
resources R, to achieve a separation of the formula. 4 References 4.1 Normative References [OWL-Semantics] OWL Webinterpretation of
class, datatype, ontology Language Semanticsproperty, datatype property, annotation
property, and Abstract Syntaxontology property identifiers.
DEFINITION: Given a conforming datatype map
D, a common-rif-dl-interpretation
is a pair (I, P. F. Patel-Schneider, P. Hayes, I. Horrocks, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-semantics-20040210/ . Latest version available at http://www.w3.org/TR/owl-semantics/ . [RDF-CONCEPTS] Resource Description Framework (RDF): Concepts and Abstract SyntaxI), where I =
<TV, G. Klyne, J. Carroll (Editors), W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-concepts-20040210/ . Latest version available at http://www.w3.org/TR/rdf-concepts/ . [RDF-SEMANTICS] RDF SemanticsDTS, P. Hayes, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-mt-20040210/ . Latest version available at http://www.w3.org/TR/rdf-mt/ . [RIF-BLD] RIF Basic Logic DialectD,
H. Boley, M. Kifer (Editors), W3C Editor's Draft, http://www.w3.org/2005/rules/wg/wiki/BLD . Accessed on 2008-02-13T17:00 UTC. [XML-SCHEMA2] XML Schema Part 2: DatatypesIC, W3C Recommendation, World Wide Web Consortium, 2 May 2001. This version is http://www.w3.org/TR/2001/REC-xmlschema-2-20010502/ . Latest version available at http://www.w3.org/TR/xmlschema-2/ . 4.2 Informational References [RDF-Schema] RDF Vocabulary Description Language 1.0: RDF SchemaIV,
D. Brickley, R.V. Guha, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-schema-20040210/ . Latest version available at http://www.w3.org/TR/rdf-schema/ . [RDF-SYNTAX] RDF/XML Syntax Specification (Revised)IF, D. Beckett, Editor, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-rdf-syntax-grammar-20040210/ . Latest version available at http://www.w3.org/TR/rdf-syntax-grammar/ . [RFC-3066] RFC 3066 - Tags for the Identification of LanguagesIframe',
H. Alvestrand, IETF, January 2001. This document is http://www.isi.edu/in-notes/rfc3066.txt . [RIF-PRD] RIF Production Rule dialectISF, C. de Sainte Marie (Editors), Editor's Draft. Latest version available at http://www.w3.org/2005/rules/wg/wiki/PRdialect . [RIF-UCR] RIF Use Cases and RequirementsIsub,
A. Ginsberg, D. Hirtle, F. !McCabe, P.-L. Patranjan (Editors), W3C Working Draft, 10 July 2006, http://www.w3.org/TR/2006/WD-rif-ucr-20060710/ . Latest version available at http://www.w3.org/TR/rif-ucr . [OWL-Reference] OWL Web Ontology Language ReferenceIisa, M. Dean, G. Schreiber, Editors, W3C Recommendation, 10 February 2004, http://www.w3.org/TR/2004/REC-owl-ref-20040210/ . Latest version available at http://www.w3.org/TR/owl-ref/ . 5 Appendix: Embeddings RIF-RDF combinations can be embedded into RIF Rule sets inI=,
ITruth> is a fairly straightforward way, thereby demonstrating how an RIF-compliant translator without native support for RDF can process RIF-RDF combinations. For the embedding we use the concrete syntax ofRIF DL-semantic structure and
the N-Triples syntax for RDF. Throughout this section the function trI=<R, EC, ER, L, S, LV> is defined, which maps symbols, triples, and RDF graphsan abstract OWL
interpretation with respect to RIF symbols, statements, and rule sets. 5.1 Embedding Symbols Given a combination C=< R , S >, the function tr maps RDF symbolsD of a vocabulary V and a set of blank nodes B to RIF symbols, as defined in, such
that the following table. RDF Symbol RIF Symbol Mapping IRI i in Vconditions hold
Condition 1 ensures that the symbol spacerelevant parts of the domains of
interpretation are the same. Condition 2 ensures that the
interpretation (extension) of an OWL DL class u
tr( "s"^^ucorresponds to the interpretation of frames of the form
?x[rdf:type -> "u"^^rif:iri]. Condition 3 ensures that
the interpretation (extension) of an OWL DL object or datatype
property u corresponds to to the interpretation of frames
of the form ?x["u"^^rif:iri -> ?y]. Condition 4
ensures that typed literals of the form (s, d) in
OWL DL are interpreted in the same way as constants of the form
"s"^^d in RIF. Finally, condition 5 ensures that
individual identifiers in the OWL ontologies and the RIF rulesets
are interpreted in the same way.
Using the definition of common-rif-dl-interpretation, satisfaction,
models, and entailment are defined in the usual way:
DEFINITION: Given a conforming datatype map D, a common-rif-dl-interpretation (I, I) is an OWL-DL-model of a RIF-OWL-DL-combination C=< R, O > if I is a model of R and I satisfies every OWL DL ontology in abstract syntax form O in O; in this case C is OWL-DL-satisfiable. (I, I) is an OWL-DL-model of an OWL DL ontology in abstract syntax form O if I satisfies O. (I, I) is an OWL-DL-model of a closed RIF-BLD condition φ if Itruth(φ)=t.
DEFINITION: Given a conforming datatype map D, a RIF-OWL-DL-combination C OWL-DL-entails an OWL DL ontology in abstract syntax form O if every OWL-DL-model of C is an OWL-DL-model of O. Likewise, C OWL-DL-entails a closed RIF DL-condition φ if every OWL-DL-model of C is an OWL-DL-model of φ.
Recall that in an abstract OWL interpretation I the sets O, which
is used for interpreting individuals, and LV, which is used for
interpreting literals (data values), are disjoint and that EC maps
class identifiers to subsets of O and datatype identifiers to
subsets of LV. The disjointness entails that data values cannot be
member sof a class and individuals cannot be members of a
datatype.
In RIF, variable quantification ranges over Dind. So, the same variable may be assigned to an abstract individual or a concrete data value. Additionally, RIF constants (e.g., IRIs) denoting individuals can be written in place of a data value, such as the value of a data-valued property or in datatype membership statements; similar for constants denoting data values. Such statements cannot be satisfied in any common-rif-dl-interpretation, due to the constraints on the EC and ER functions. The following example illustrates several such statements.
Consider the datatype xsd:string and a RIF-OWL DL combination consisting of the set containing only the OWL DL ontology
ex:myiri rdf:type ex:A .
and a RIF ruleset containing the following fact
ex:myiri[rdf:type -> xsd:string]
This combination is not OWL-DL-satisfiable, because ex:myiri is an individual identifier and S maps individual identifiers to elements in O, which is disjoint from the elements in the datatype xsd:string.
Consider a RIF-OWL DL combination consisting of the set containing only the OWL DL ontology
ex:hasChild rdf:type owl:ObjectProperty .
and a RIF ruleset containing the following fact
ex:myiri[ex:hasChild -> "John"^^xsd:string]
This combination is not OWL-DL-satisfiable, because ex:hasChild is an object property, and values of object properties may not be concrete data values.
Consider a RIF-OWL DL combination consisting of the OWL DL ontology
ex:A rdfs:subClassOf ex:B
and a RIF ruleset containing the following rule
Forall ?x ?x[rdf:type -> ex:A]
This combination is not OWL-DL-satisfiable, because the rule requires every element, including every concrete data value, to be a member of the class ex:A. However, the mapping EC in any abstract OWL interpretation requires every member of ex:A to be an element of O, and concrete data values may not be members of O.
Note that the above definition of RIF-OWL DL compatibility does not consider ontology and annotation properties, in contrast to the definition of compatibility of RIF with OWL Full, where there is no clear distinction between annotation and ontology properties and other kinds of properties. Therefore, it is not possible to "access" or use the values of these properties in the RIF rules. This limitation is overcome in the following definition. It is envisioned that the user will choose whether annotation and ontology properties are to be considered. It is currently expected that OWL 1.1 will not define a semantics for annotation and ontology properties; therefore, the below definition cannot be extended to the case of OWL 1.1.
DEFINITION: Given a conforming datatype map D, a common-rif-dl-interpretation (I, I) is a common-DL-annotation-interpretation if the following condition holds
6. ER(u) = set of all pairs (k, l) in O × O such that Itruth(Iframe'(IC("u"^^rif:iri))( k, l) ) = t (true), for every IRI u in V.
Condition 6, which strengthens condition 3, ensures that the
interpretation of all properties (also annotation and ontology
properties) in the OWL DL ontologies corresponds with their
interpretation in the RIF rules.
DEFINITION: Given a conforming datatype map D, a common-DL-annotation-interpretation (I, I) is an OWL-DL-annotation-model of a RIF-OWL-DL-combination C=< R, O > if I is a DL-model of R and I satisfies every OWL DL ontology in abstract syntax form O in O; in this case C is OWL-DL-annotation-satisfiable.
DEFINITION: Given a conforming datatype map D, a RIF-RDF-combination C OWL-DL-annotation-entails an OWL DL ontology in abstract syntax form O if every OWL-DL-annotation-model of C is an OWL-DL-model of O. Likewise, C OWL-DL-annotation-entails a closed RIF-BLD condition φ if every OWL-DL-annotation-model of C is an OWL-DL-model of φ.
The difference between the two kinds of OWL DL entailment can be illustrated using an example. Consider the following OWL DL ontology in abstract syntax form
Ontology (ex:myOntology Annotation(dc:title "Example ontology"))
which defines an ontology with a single annotation (title). Consider also a ruleset consisting of the following rule:
Forall ?x, ?y ( ?x[ex:hasTitle -> ?y] :- ?x[dc:title -> ?y])
which says that whenever something has a dc:title, it has the same ex:hasTitle.
The combination of the ontology and the ruleset OWL-DL-annotation-entails the RIF condition formula ex:myOntology[ex:hasTitle -> "Example ontology"^^xsd:string]; the combination does not OWL-DL-entail the formula.
RIF-RDF-combinations can be embedded into RIF Rulesets in a fairly straightforward way, thereby demonstrating how a RIF-compliant translator without native support for RDF can process RIF-RDF-combinations.
RIF-OWL combinations cannot be embedded in RIF, in the general case. However, there is a subset of RIF-OWL DL combinations that can be embedded.
Throughout this section the function tr is defined, which maps
symbols, triples, RDF graphs, and OWL DL ontologies in abstract
syntax form to RIF symbols, statements, and rulesets.
Given a combination C=< R,S>, the function tr maps RDF symbols of a vocabulary V and a set of blank nodes B to RIF symbols, as defined in following table.
RDF Symbol | RIF Symbol | Mapping |
---|---|---|
IRI i in VU | Constant with symbol space rif:iri | tr(i) = "i"^^rif:iri |
Blank node x in B | Variable symbols ?x | tr(x) = ?x |
Plain literal without a language tag xxx in VPL | Constant with the datatype xsd:string | tr("xxx") = "xxx"^^xsd:string |
Plain literal with a language tag (xxx,lang) in VPL | Constant with the datatype rif:text | tr("xxx"@lang) = "xxx@lang"^^rif:text |
Well-typed literal (s,u) in VTL | Constant with the symbol space u | tr("s"^^u) = "s"^^u |
Ill-typed literal (s,u) in VTL | Constant s^^u' with symbol space rif:local that is not used in C | tr("s"^^u) = "s^^u'"^^rif:local |
The embedding is not defined for combinations that include RDF graphs with RDF URI references that are not absolute IRIs.
The mapping function tr is extended to embed triples as RIF statements. Finally, two embedding functions, trR and trQ embed RDF graphs as RIF rulesets and conditions, respectively. The following section shows how these embeddings can be used for reasoning with combinations.
We define two mappings for RDF graphs, one (trR) in which variables are Skolemized, i.e., replaced with constant symbols, and one (trQ) in which variables are existentially quantified.
The function sk takes as an argument a formula R with variables, and returns a formula R', which is obtained from R by replacing every variable symbol ?x in R with "new-iri"^^rif:iri, where new-iri is a new globally unique IRI.
RDF Construct | RIF Construct | Mapping |
---|---|---|
Triple s p o . | Frame formula tr(s)[tr(p) -> tr(o)] | tr(s p o .) = tr(s)[tr(p) -> tr(o)] |
Graph S | Ruleset trR(S) | trR(S) = the set of all sk(Forall tr(s p o .)) where s p o . is a triple in S |
Graph S | Condition (query) trQ(S) | trQ(S) = Exists tr(x1), ..., tr(xn) And(tr(t1) ... tr(tm)), where x1, ..., xn are the blank nodes occurring in S and t1, ..., tm are the triples in S |
The following theorem shows how checking simple-entailment of combinations can be reduced to checking entailment of RIF conditions by using the embeddings of RDF graphs of the previous section.
Theorem A combination C=<R,{S1,...,Sn}> simple-entails a generalized RDF graph S iff (R union trR(S1) union ... union trR(Sn)) entails trQ(S). C simple-entails a RIF condition φ iff (R union trR(S1) union ... union trR(Sn)) entails φ.
The embeddings of RDF and RDFS entailment require a number of built-in predicate symbols to be available to appropriately deal with literals.
EDITORS NOTE: It is not yet clear which built-in predicates will be available in RIF. Therefore, the built-ins mentioned in this section may change. Furthermore, built-ins may be axiomatized if they are not provided by the language.
Given a vocabulary V,
We axiomatize the semantics of the RDF vocabulary using the following RIF rules and conditions.
The compact URIs used in the RIF rules in this section and the next are short for the complete URIs with the rif:iri datatype, e.g., rdf:type is short for "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"^^rif:iri
RRDF | = | (Forall tr(s p o .)) for every RDF axiomatic
triple s p o .) union ( Forall ?x ?x[rdf:type -> rdf:Property] :- Exists ?y,?z (?y[?x -> ?z]),) |
Theorem A combination <R,{S1,...,Sn}> is
rdf-satisfiable iff (RRDF union R union
trR(S1) union ... union trR(Sn)) has a
model.
Theorem A combination C=<R,{S1,...,Sn}> rdf-entails a generalized RDF graph T iff (RRDF union R union trR(S1) union ... union trR(Sn)) entails trQ(T). C simple-entails a RIF condition φ iff (RRDF union R union trR(S1) union ... union trR(Sn)) entails φ.
We axiomatize the semantics of the RDF(S) vocabulary using the following RIF rules and conditions.
RRDFS | = | RRDF union (Forall tr(s p o .)) for every RDFS
axiomatic triple s p o .) union Forall ?x ?x[rdf:type -> rdfs:Resource],) |
Theorem A combination <R1,{S1,...,Sn}> is
rdfs-satisfiable iff (RRDFS union R1
union trR(S1) union ... union trR(Sn)) has a
model.
Theorem A combination <R,{S1,...,Sn}> rdfs-entails a generalized RDF graph T iff (RRDFS union R union trR(S1) union ... union trR(Sn)) entails trQ(T). C rdfs-entails a RIF condition φ iff (RRDFS union R union trR(S1) union ... union trR(Sn)) entails φ.
We axiomatize the semantics of the data types using the following RIF rules and conditions.
RD | = | RRDFS union (Forall u[rdf:type -> rdfs:Datatype] | for every IRI
u in the domain of D) union |
Theorem A combination <R,{S1,...,Sn}>, where R does not contain the equality symbol, is D-satisfiable iff (RD union R union trR(S1) union ... union trR(Sn)) is satisfiable and does not entail Exists ?x And(dt(?x,u) dt(?x,u')) for any two URIs u and u' in the domain of D such that the value spaces of D(u) and D(u') are disjoint, and does not entail Exists ?x dt(s^^u,"u'"^^rif:iri) for any (s, u) in VTL and u' in the domain of D such that s is not in the lexical space of D(u').
EDITOR'S NOTE: Since this condition is very complex we might consider discarding this theorem, and suggest the above set of rules (RD) as an approximation of the semantics.
Theorem A D-satisfiable combination <R,{S1,...,Sn}>,
where R does not contain the equality symbol, D-entails a
generalized RDF graphs T iff (RD union R union
trR(S1) union ... union trR(Sn)) entails
trQ(T). C D-entails a RIF condition φ iff
(RD union R union trR(S1) union ...
union trR(Sn)) entails φ.
EDITOR'S NOTE: The restriction to equality-free rulesets is necessary because, in case different datatype URIs are equal, D-interpretations impose stronger conditions on the interpretation of typed literals than RIF does.
It is known that expressive Description Logic languages such as OWL DL cannot be straightforwardly embedded into typical rules languages such as RIF BLD.
In this section we therefore consider a subset of OWL DL in RIF-OWL DL combinations. We define OWL DLP, which is inspired by so-called Description Logic programs (DLP), and define how reasoning with RIF-OWL DLP combinations can be reduced to reasoning with RIF.
Our definition of OWL DLP removes disjunction and extensional quantification from consequents of implications and removes negation and equality.
We introduce OWL DLP through its abstract syntax, which is a subset of the abstract syntax of OWL DL. The semantics of OWL DLP is the same as OWL DL.
The basic syntax of ontologies and identifiers remains the same.
ontology ::= 'Ontology(' [ ontologyID ] { directive } ')' directive ::= 'Annotation(' ontologyPropertyID ontologyID ')' | 'Annotation(' annotationPropertyID URIreference ')' | 'Annotation(' annotationPropertyID dataLiteral ')' | 'Annotation(' annotationPropertyID individual ')' | axiom | fact
datatypeID ::= URIreference classID ::= URIreference individualID ::= URIreference ontologyID ::= URIreference datavaluedPropertyID ::= URIreference individualvaluedPropertyID ::= URIreference annotationPropertyID ::= URIreference ontologyPropertyID ::= URIreference
dataLiteral ::= typedLiteral | plainLiteral typedLiteral ::= lexicalForm^^URIreference plainLiteral ::= lexicalForm | lexicalForm@languageTag lexicalForm ::= as in RDF, a unicode string in normal form C languageTag ::= as in RDF, an XML language tag
Facts are the same as for OWL DL, except that equality and
inequality (SameIndividual and DifferentIndividual), as well as
individuals without an identifier are not allowed.
fact ::= individual individual ::= 'Individual(' individualID { annotation } { 'type(' type ')' } { value } ')' value ::= 'value(' individualvaluedPropertyID individualID ')' | 'value(' individualvaluedPropertyID individual ')' | 'value(' datavaluedPropertyID dataLiteral ')'
type ::= Rdescription
The main restrictions posed by OWL DLP on the OWL DL syntax are on descriptions and axioms. Specifically, we need to distinguish between descriptions which are allowed on the right-hand side (Rdescription) and those allowed on the left-hand side (Ldescription) of subclass statements.
We start with descriptions that may be allowed on both sides
dataRange ::= datatypeID | 'rdfs:Literal'
description ::= classID | restriction | 'intersectionOf(' { description } ')'
restriction ::= 'restriction(' datavaluedPropertyID dataRestrictionComponent { dataRestrictionComponent } ')' | 'restriction(' individualvaluedPropertyID individualRestrictionComponent { individualRestrictionComponent } ')' dataRestrictionComponent ::= 'value(' dataLiteral ')' individualRestrictionComponent ::= 'value(' individualID ')'
We then proceed with the individual sides
Ldescription ::= description | Lrestriction | 'unionOf(' { Ldescription } ')' | 'intersectionOf(' { Ldescription } ')' | 'oneOf(' { individualID } ')'
Lrestriction ::= 'restriction(' datavaluedPropertyID LdataRestrictionComponent { LdataRestrictionComponent } ')' | 'restriction(' individualvaluedPropertyID LindividualRestrictionComponent { LindividualRestrictionComponent } ')' LdataRestrictionComponent ::= 'someValuesFrom(' dataRange ')' | 'value(' dataLiteral ')' LindividualRestrictionComponent ::= 'someValuesFrom(' description ')' | 'value(' individualID ')'
Rdescription ::= description | Rrestriction | 'intersectionOf(' { Rdescription } ')'
Rrestriction ::= 'restriction(' datavaluedPropertyID RdataRestrictionComponent { RdataRestrictionComponent } ')' | 'restriction(' individualvaluedPropertyID RindividualRestrictionComponent { RindividualRestrictionComponent } ')' RdataRestrictionComponent ::= 'allValuesFrom(' dataRange ')' | 'value(' dataLiteral ')' RindividualRestrictionComponent ::= 'allValuesFrom(' description ')' | 'value(' individualID ')'
Finally, we turn to axioms. We start with class axioms.
axiom ::= 'Class(' classID ['Deprecated'] 'complete' { annotation } { description } ')' axiom ::= 'Class(' classID ['Deprecated'] 'partial' { annotation } { Rdescription } ')'
axiom ::= 'DisjointClasses(' Ldescription Ldescription { Ldescription } ')' | 'EquivalentClasses(' description { description } ')' | 'SubClassOf(' Ldescription Rdescription ')'
axiom ::= 'Datatype(' datatypeID ['Deprecated'] { annotation } )'
Property axioms in OWL DLP restrict those in OWL DL by disallowing functional and inverse functional properties, because these involve equality.
axiom ::= 'DatatypeProperty(' datavaluedPropertyID ['Deprecated'] { annotation } { 'super(' datavaluedPropertyID ')'} { 'domain(' description ')' } { 'range(' dataRange ')' } ')' | 'ObjectProperty(' individualvaluedPropertyID ['Deprecated'] { annotation } { 'super(' individualvaluedPropertyID ')' } [ 'inverseOf(' individualvaluedPropertyID ')' ] [ 'Symmetric' ] [ 'Transitive' ] { 'domain(' description ')' } { 'range(' description ')' } ')' | 'AnnotationProperty(' annotationPropertyID { annotation } ')' | 'OntologyProperty(' ontologyPropertyID { annotation } ')'
axiom ::= 'EquivalentProperties(' datavaluedPropertyID datavaluedPropertyID { datavaluedPropertyID } ')' | 'SubPropertyOf(' datavaluedPropertyID datavaluedPropertyID ')' | 'EquivalentProperties(' individualvaluedPropertyID individualvaluedPropertyID { individualvaluedPropertyID } ')' | 'SubPropertyOf(' individualvaluedPropertyID individualvaluedPropertyID ')'
EDITOR'S NOTE: Data ranges as the range of datatype properties requires built-ins of the form isNotString in RIF.
Recall that the semantics of frame formulas in DL-rulesets is different from the semantics of frame formulas in RIF BLD.
Frame formulas in DL-rulesets are embedded as predicates in RIF BLD.
The mapping tr is the identity mapping on all RIF formulas, with the exception of frame formulas.
RIF Construct | Mapping |
---|---|
Term x | tr(x)=x |
Atomic formula x that is not a frame formula | tr(x)=x |
a[b -> c], where a,c are terms and b ≠ rdf:type is a constant | tr(a[b -> c])=b'(a,c), where b' is a constant symbol obtained from b that does not occur in the original ruleset or the ontologies |
a[rdf:type -> c], where a is a term and c is a constant | tr(a[rdf:type -> c])=c'(a), where c' is a constant symbol obtained from c that does not occur in the original ruleset or the ontologies |
Exists ?V1 ... ?Vn(φ) | tr(Exists ?V1 ... ?Vn(φ))=Exists ?V1 ... ?Vn(tr(φ)) |
And(φ1 ... φn) | tr(And(φ1 ... φn))=And(tr(φ1) ... tr(φn)) |
Or(φ1 ... φn) | tr(Or(φ1 ... φn))=Or(tr(φ1) ... tr(φn)) |
φ1 :- φ2 | tr(φ1 :- φ2)=tr(φ1) :- tr(φ2) |
Forall ?V1 ... ?Vn(φ) | tr(Forall ?V1 ... ?Vn(φ))=Forall ?V1 ... ?Vn(tr(φ)) |
Ruleset(φ1 ... φn) | tr(Ruleset(φ1 ... φn))=Ruleset(tr(φ1) ... tr(φn)) |
The embedding of OWL DLP into RIF BLD has two stages: normalization and embedding.
Normalization splits the OWL axioms so that the mapping of the individual axioms results in rules. Additionally, it simplifies the abstract syntax and removes annotations.
EDITOR'S NOTE: embedding OWL-DL-annotation semantics would require maintaining the annotation properties
Complex OWL | Normalized OWL | |
---|---|---|
trN(
Ontology( [ ontologyID ]
directive1
...
directiven )
) |
trN(directive1)
...trN(directiven) |
|
trN(Annotation( ... )) | ||
trN(
Individual( individualID
annotation1
...
annotationn
type1
...
typem
value1
...
valuek )
) |
trN(Individual( individualID type1 )) ... trN(Individual( individualID typem ))
Individual( individualID value1 )
...
Individual( individualID valuek )
|
|
trN(
Individual( individualID
type(intersectionOf(
description1
...
descriptionn
))
) |
trN(Individual( individualID type(description1) )) ... trN(Individual( individualID type(descriptionn) )) |
|
trN(
Individual( individualID type(X))) |
Individual( individualID type(X)) |
X is a classID or value restriction |
trN(
Individual( individualID type(restriction(propertyID allValuesFrom(X))))) |
trN(
SubClassOf( oneOf(individualID) restriction(propertyID allValuesFrom(X))) ) |
|
trN(
Class( classID [Deprecated]
complete
annotation1
...
annotationn
description1
...
descriptionm )
) |
trN(
EquivalentClasses(classID
intersectionOf(description1
...
descriptionm )
) |
|
trN(
Class( classID [Deprecated]
partial
annotation1
...
annotationn
description1
...
descriptionm )
) |
trN(
SubClassOf(classID
intersectionOf(description1
...
descriptionm )
) |
|
trN(
DisjointClasses(
description1
...
descriptionm )
) |
trN(SubClassOf(intersectionOf(description1
description2) owl:Nothing))
... trN(SubClassOf(intersectionOf(description1 descriptionm) owl:Nothing)) ... trN(SubClassOf(intersectionOf(descriptionm-1 descriptionm) owl:Nothing)) |
|
trN(
EquivalentClasses(
description1
...
descriptionm )
) |
trN(SubClassOf(description1 description2)) trN(SubClassOf(description2 description1)) ... trN(SubClassOf(descriptionm-1 descriptionm)) trN(SubClassOf(descriptionm descriptionm-1)) |
|
trN(
SubClassOf(description X)) |
SubClassOf(description X) |
X is a description that does not contain intersectionOf |
trN(
SubClassOf(description
...intersectionOf(
description1
...
descriptionn
)...)
) |
trN(SubClassOf(description ...description1...)) ... trN(SubClassOf(description ...descriptionn...)) |
|
trN(Datatype( ... )) | ||
trN(
DatatypeProperty( propertyID [ Deprecated ]
annotation1
...
annotationn
super(superproperty1)
...
super(superpropertym)
domain(domaindescription1)
...
domain(domaindescriptionj)
range(rangedescription1)
...
range(rangedescriptionk) )
) |
SubPropertyOf(propertyID superproperty1)
...
SubPropertyOf(propertyID superpropertym)
trN(SubClassof(restriction(propertyID someValuesFrom(owl:Thing)) domaindescription1)) ... trN(SubClassof(restriction(propertyID someValuesFrom(owl:Thing)) domaindescriptionj)) trN(SubClassof(owl:Thing restriction(propertyID allValuesFrom(rangedescription1))) ... trN(SubClassof(owl:Thing restriction(propertyID allValuesFrom(rangedescriptionk))) |
|
trN(
ObjectProperty( propertyID [ Deprecated ]
annotation1
...
annotationn
super(superproperty1)
...
super(superpropertym)
[ inverseOf( inversePropertyID ) ]
[ Symmetric ]
[ Transitive ]
domain(domaindescription1)
...
domain(domaindescriptionl)
range(rangedescription1)
...
range(rangedescriptionk) )
) |
SubPropertyOf(propertyID superproperty1)
...
SubPropertyOf(propertyID superpropertym)
trN(SubClassof(restriction(propertyID someValuesFrom(owl:Thing)) domaindescription1)) ... trN(SubClassof(restriction(propertyID someValuesFrom(owl:Thing)) domaindescriptionl)) trN(SubClassof(owl:Thing restriction(propertyID allValuesFrom(rangedescription1))) ... trN(SubClassof(owl:Thing restriction(propertyID allValuesFrom(rangedescriptionk))) ObjectProperty( propertyID [ inverseOf( inversePropertyID ) ] ) ObjectProperty( propertyID [ Symmetric ] ) ObjectProperty( propertyID [ Transitive ] ) |
|
trN(
EquivalentProperties(
property1
...
propertym )
) |
trN(SubPropertyOf(property1 property2)) trN(SubPropertyOf(property2 property1))
trN( |
= "s^^u'"^^rif:localThe embedding is not defined for combinations which include RDF graphs with RDF URI references which are not absolute IRIs. 5.2 Embedding Triples and Graphsresult of the mapping function trnormalization is extended to embed triples as RIF statements. Finally, two embedding functions, tr Ra set of individual property
value, individual typing, subclass, subproperty, and tr Q embed RDF graphs as RIF rule setsproperty
inverse, symmetry and conditions, respectively. The following section shows how these embeddings can be used for reasoning with combinations.transitive statements.
We define two mappings for RDF graphs, one (tr R ) in which variables are Skolemized, i.e. replacednow proceed with constant symbols, and one (tr Q ) in which variables are existentially quantified.the function sk takes as arguments a formula R with variables, and returns a formula R', which is obtained from R by replacing every variable symbol ? x in R with "new-iri"^^rif:iri , where new-iri is a new globally unique IRI. </table> 5.3embedding Simple Entailment The following theorem shows how checking simple-entailment of combinations can be reduced to checking entailmentof normalized OWL DL
ontologies into a RIF conditions by usingDL-ruleset. The embeddings of RDF graphs ofembedding extends the
previous section. Theorem A combination C=<R,{S1,...,Sn}> simple-entails a generalized RDF graph S iff (R union tr R (S1) union ... union tr R (Sn)) entails tr Q (S). C simple-entails an RIF condition φ iff (R union tr R (S1) union ... union tr R (Sn)) entails φ. 5.4 Built-ins requiredembedding function tr. The embeddings of RDFIRIs and RDFS entailment require a number of built-in predicate symbols to be available to appropriately deal with literals. EDITORS NOTE: Itliterals is not yet clear which built-in predicates will be availableas
defined in RIF. Therefore,the built-ins mentioned in thisSection may change. Furthermore, built-ins may be axiomatized if they are not provided by the language. Given#Embedding_Symbols.
EDITOR'S NOTE: This embedding assumes that for a vocabulary Vgiven
datatype identifier D, the unary predicate wellxml V /1there is interpreted as the set of XML values, theunary built-in
predicate illxml V /1is interpreted as the set of objects corresponding to ill-typed XML literals in V TLD, andcalled the unary predicate illD V /1"positive guard" for
D, which is always interpreted as the setvalue space
of objects corresponding to ill-typed literals in V TL ,the datatype denoted by D and there is a
built-in isNotD, called the unary predicate lit/1"negative guard" for
D, which is always interpreted as the unioncomplement of
the value spaces of all data types. 5.5 Embedding RDF Entailment We axiomatize the semanticsspace of the RDF vocabulary using the following RIF rules and conditions. The compact URIs used in thedatatype denoted by D.
Normalized OWL | RIF |
|
---|---|---|
trO(
directive1
...
directiven
) |
trO(directive1)
...trO(directiven) |
|
trO(
Individual( individualID type(A) )) |
tr(individualID)[rdf:type -> tr(A)] |
A is |
trO Individual( individualID type(restriction(propertyID value(b))) )) |
tr( |
|
Individual( individualID value(propertyID b) )) |
|
|
) |
Forall ?x, ?y
(?x[tr( |
|
tr ) |
||
tr
) |
Forall ?x, ?y (?y[tr(property2) -> ?x] :- ?x[tr(property1) -> ?y]) Forall ?x, ?y (?y[tr(property1) -> ?x] :- ?x[tr(property2) -> ?y]) |
|
tr ObjectProperty(propertyID Symmetric )) |
Forall ?x, ?y (?y[tr(propertyID) -> ?x] :- ?x[tr(propertyID) -> ?y]) |
|
tr ) |
Forall ?x, ?y, ?z
(?x[tr( |
|
trO
SubClassOf(description1 description2)
) |
trO |
|
|
Forall ?x (trO(X,
|
X is a classID or value restriction |
trO(description1,D, |
Forall ?x (trO(owl:Nothing,
|
D is a datatypeID and |
trO(description1,restriction(property1
allValuesFrom(...restriction(propertyn
allValuesFrom(X)) ...)), |
Forall ?x, ?y1,
|
X is a classID or value restriction |
trO(description1, |
Forall ?x, ?y1,
..., ?yn (trO(owl:Nothing,
?yn) :- |
D is a datatypeID or value restriction |
trO(A, |
?x[rdf:type |
A is a classID |
trO(D, |
|
D is a |
trO( |
And(tr |
|
tr |
Or(tr |
|
|
|
|
trO( |
Exists ?y(And(?x[tr(propertyID)
-> ?y] tr |
|
tr |
|
|
trO( |
|
|
trO( |
|
Theorem A D-satisfiable combination <R,{S1,...,Sn}>, whereRIF-OWL-DL-combination
<R does not contain the equality symbol, D-entails a generalized RDF graphs T,{O1,...,On}>, where
O1,...,On are OWL DLP ontologies, is OWL-DL-satisfiable iff
( R D uniontr(R union tr R (S1)O(trN(O1))
union ... union tr R (Sn)) entails tr Q (T). C D-entailsO(trN(On))) has
a model.
Theorem An OWL-DL-satisfiable RIF-OWL-DL-combination
C=<R,{O1,...,On}>, where
O1,...,On are OWL DLP ontologies, OWL-DL-entails a closed RIF
condition φ iff ( R D uniontr(R union
tr R (S1)O(trN(O1)) union ... union
tr R (Sn))O(trN(On))) entails φ.
RDF URI
References: There are certain RDF URI references whichthat
are not absolute IRIs (e.g.(e.g., those containing spaces). It is
possible to use such RDF URI references in RDF graphs whichthat are
combined with RIF rules. However, such URI references cannot be
represented in RIF rules and their use in RDF is discouraged.
Generalized RDF
graphs: Standard RDF
graphs, as defined in [(RDF-Concepts ],), do not allow the use of literals in subject
and predicate positions and blank nodes in predicate positions. The
RDF Core working
group has listed two issues
questioning the restrictions that literals
may not occur in subject and blank
nodes may not occur in predicate positions in triples.
Anticipating lifting of these restrictions in a possible future
version of RDF, we use the more liberal notion of
generalized RDF graph. We note that the definitions of
interpretations, models, and entailment in the RDF semantics
document [(RDF-Semantics ])
also apply to such generalized RDF graphs.
We note that every standard RDF graph is a generalized RDF graph. Therefore, our definition of combinations applies to standard RDF graphs as well.
We note also that the notion of generalized RDF graphs is more liberal than the notion of RDF graphs used by SPARQL; generalized RDF graphs additionally allow blank nodes and literals in predicate positions.