Embedding OWL in RDFS

Peter F. Patel-Schneider Bell Labs Research

Basic ideas:

The extension of owl:Thing is a subset of IR. (This is taken from Pat
Hayes's document.)

The denotation of OWL syntax is not in the extension of owl:Thing.

The denotation of OWL classes and properties are not in the
extension of owl:Thing.

All possible descriptions are added to the domain of discourse through
semantic comprehension principles.

Problems:

Only works for OWL knowledge bases with separated names.

More complex than a direct model theory.

Details:

Let KB be an OWL knowledge base with separated names. This means, among
other things, that no name in KB is more than one of an individual, a
class, or a property.
Let R be the translation from OWL abstract syntax to RDF as defined in the
OWL model theory document.

An OWL/RDF interpretation of R(KB) is an RDFS interpretation of R(KB) that
satisfies the following conditions:

RDFS subclasses, subproperties, domains, and ranges are strengthened
to if-and-only-if.

The class extension of owl:Thing is a subset of IR, does not contain
any RDF or OWL structural resources, and is disjoint from
the extensions of classes, properties, lists, collections,
statements, and literals.

for each name N in the rdf:, rdfs:, and owl: namespaces,
IS(N) is not in ICEXT(IS(owl:Thing))

ICEXT(IS(owl:Thing)) is disjoint from ICEXT(IS(rdfs:Class))

ICEXT(IS(owl:Thing)) is disjoint from ICEXT(IS(rdf:Property))

ICEXT(IS(owl:Thing)) is disjoint from ICEXT(IS(rdf:List))

ICEXT(IS(owl:Thing)) is disjoint from ICEXT(IS(rdf:Collection))

ICEXT(IS(owl:Thing)) is disjoint from ICEXT(IS(rdf:Statement))

ICEXT(IS(owl:Thing)) is disjoint from LV

OWL individuals, classes, and properties belong to owl:Thing,
owl:Class, owl:DatatypeProperty, or owl:ObjectProperty, as appropriate.
OWL classes and properties have the class extension of
owl:Thing as their domain of discourse. OWL properties have the
appropriate range.

for each <individualID> in KB,
IS(<individualID>) in ICEXT(IS(owl:Thing))

for each <classID> in KB,
IS(<classID>) in ICEXT(IS(owl:Class))

for each <datavaluedPropertyID> in KB,
IS(<datavaluedPropertyID>) in ICEXT(IS(owl:DatatypeProperty))

for each <individualvaluedPropertyID> in KB,
IS(<individualvaluedPropertyID>) in ICEXT(IS(owl:ObjectProperty))

for each <classID> in KB,
ICEXT(IS(<classID>)) contained in ICEXT(IS(owl:Thing))

for each <datavaluedPropertyID> in KB,
IEXT(IS(<datavaluedPropertyID>) contained in
ICEXT(IS(owl:Thing)) x LV

for each <individualvaluedPropertyID> in KB,
IEXT(IS(<individualvaluedPropertyID>) contained in
ICEXT(IS(owl:Thing)) x ICEXT(IS(owl:Thing))

Conditions for the owl: resources that show up in the translation.
Conditions for OWL ``constructors'' are only-if conditions;
conditions for other OWL stuff are if-and-only-if conditions.

<x,_:l1> in IEXT(IS(?))
<_:l1,y1> in IEXT(IS(rdf:first))
<_:l1,_:l2> in IEXT(IS(rdf:rest))
...
<_:ln,yn> in IEXT(IS(rdf:first))
<_:ln,IS(rdf:nil)> in IEXT(IS(rdf:rest))

ONLY IF ICEXT(x) = ?

owl:unionOf

ICEXT(y1) v ... v ICEXT(yn)

owl:intersectionOf

ICEXT(y1) ^ ... ^ ICEXT(yn)

owl:oneOf

{ y1, ..., yn }

<x,y> in IEXT(IS(?))

ONLY IF

owl:complementOf

ICEXT(x) = ICEXT(IS(owl:Thing)) - ICEXT(y)

owl:inverseOf

IEXT(x) is the converse of IEXT(y)

<x,p> in IEXT(IS(owl:onProperty))<x,d> in
IEXT(IS(?))

ONLY IF ICEXT(x) = ICEXT(IS(owl:Thing)) ^ ?

owl:allValuesFrom

{ x | <x,y> in IEXT(p) -> y in ICEXT(d)}

owl:someValuesFrom

{ x | exists y <x,y> in IEXT(p) ^ y in ICEXT(d)}

owl:hasValue

{ x | <x,y> in IEXT(p) }

owl:minCardinality

{ x | exists at least d distinct y <x,y> in IEXT(p) }

owl:maxCardinality

{ x | exists at most d distinct y <x,y> in IEXT(p) }

owl:cardinality

{ x | exists exactly d distinct y <x,y> in IEXT(p) }

<x,y> in IEXT(IS(?))

IFF

owl:disjointWith

ICEXT(x) disjoint ICEXT(y)

owl:sameClassAs

ICEXT(x) = ICEXT(y)

owl:samePropertyAs

IEXT(x) = IEXT(y)

owl:sameIndividualAs

x = y

owl:differentIndividualFrom

x /= y

<x> in ICEXT(IS(?))

IFF x in ICEXT(?) and IEXT(x) is ?

owl:FunctionalProperty

owl:Property; partial functional

owl:InverseFunctionalProperty

owl:ObjectProperty; inverse partial functional

owl:SymmetricProperty

owl:ObjectProperty; symmetric

owl:TransitiveProperty

owl:ObjectProperty; transitive

The above conditions imply, for example, that
<IS(rdfs:Class),IS(rdfs:Class)&gt in IEXT(IS(owl:sameIndividualAs))
This can cause problems if owl:sameIndividualAs is given owl:Thing as
domain and range, so this is not done.
Having owl:sameIndividualAs have a broader meaning is not a problem in OWL
because the syntax of OWL knowledge bases restricts mentions of
owl:sameIndividualAs to OWL objects.

IR is augmented with objects corresponding
to all possible OWL descriptions and data ranges.
This is a bit complex, as descriptions and data ranges incorporate lists of
particular types, which also have to be in IR.
The conditions that do this are:

if there exists

then there exists y in ICEXT(IS(owl:Class)) and
l in ICEXT(IS(rdf:List)) with

x in ICEXT(IS(owl:Class))

<y,l> in IEXT(IS(owl:unionOf)) and
<l,x> in IEXT(IS(rdf:first)) and
<l,IS(rdf:nil)> in IEXT(IS(rdf:rest))

x in ICEXT(IS(owl:Class)) and
<w,l'> in IEXT(IS(owl:unionOf))

<y,l> in IEXT(IS(owl:unionOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,l'> in IEXT(IS(rdf:rest))

x in ICEXT(IS(owl:Class))

<y,l> in IEXT(IS(owl:intersectionOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,IS(rdf:nil)> in IEXT(IS(rdf:rest))

x in ICEXT(IS(owl:Class)) and
<w,l'> in IEXT(IS(owl:intersectionOf))

<y,l> in IEXT(IS(owl:intersectionOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,l'> in IEXT(IS(rdf:rest))

x in ICEXT(IS(owl:Thing))

<y,l> in IEXT(IS(owl:oneOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,IS(rdf:nil)> in IEXT(IS(rdf:rest))

x in ICEXT(IS(owl:Thing)) and
<w,l'> in IEXT(IS(owl:oneOf)) and
<l',f> in IEXT(IS(rdf:first)) and f in ICEXT(IS(owl:Thing))

<y,l> in IEXT(IS(owl:oneOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,l'> in IEXT(IS(rdf:rest))

if there exists

then there exists y in IR and
l in ICEXT(IS(rdf:List)) with

x in LV

<y,l> in IEXT(IS(owl:oneOf)) and
<l,x> in IEXT(IS(rdf:first))
and <l,IS(rdf:nil)> in IEXT(IS(rdf:rest))

x in LV and <w,l'> in IEXT(IS(owl:oneOf)) and
<l',f> in IEXT(IS(rdf:first)) and f in LV

<y,l> in IEXT(IS(owl:oneOf))
and <l,x> in IEXT(IS(rdf:first))
and <l,l'> in IEXT(IS(rdf:rest))

if there exists

then there exists y in ICEXT(IS(owl:Class)) with

x in ICEXT(IS(owl:Class))

<y,x> in IEXT(IS(owl:complementOf))

x in ICEXT(IS(owl:ObjectProperty))

<y,x> in IEXT(IS(owl:inverseOf))

if there exists

then there exists y in ICEXT(IS(owl:Restriction)) with

x in ICEXT(IS(owl:ObjectProperty)) and
w in ICEXT(IS(owl:Class))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:allValuesFrom))

x in ICEXT(IS(owl:ObjectProperty)) and
w in ICEXT(IS(owl:Class))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:someValuesFrom))

x in ICEXT(IS(owl:ObjectProperty)) and
w in ICEXT(IS(owl:Thing))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:hasValue))

x in ICEXT(IS(owl:DataTypeProperty)) and
w in ICEXT(IS(owl:DataType))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:allValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,IS(rdf:nil)> in IEXT(IS(owl:allValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty)) and
<w,l'> in IEXT(IS(owl:oneOf)) and
<l',z> in IEXT(IS(rdf:first)) and z in LV

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:allValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty)) and
w in ICEXT(IS(owl:DataType))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:someValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,IS(rdf:nil)> in IEXT(IS(owl:someValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty)) and
<w,l'> in IEXT(IS(owl:oneOf)) and
<l',z> in IEXT(IS(rdf:first)) and z in LV

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:someValuesFrom))

x in ICEXT(IS(owl:DataTypeProperty)) and w in LV

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:hasValue))

x in ICEXT(IS(owl:Property)) and
w in ICEXT(IS(xsd:NonNegativeInteger))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:minCardinality))

x in ICEXT(IS(owl:Property)) and
w in ICEXT(IS(xsd:NonNegativeInteger))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:maxCardinality))

x in ICEXT(IS(owl:Property)) and
w in ICEXT(IS(xsd:NonNegativeInteger))

<y,x> in IEXT(IS(owl:onProperty)) and
<y,w> in IEXT(IS(owl:cardinality))

The meaning of OWL resources is further specified by the following RDFS
knowledge base, called O.