We've got to figure out what compatibility means in a way that we can evaluate where we stand.

## Name Separation Issue

Name separation is required, however, if Fast OWL is to be embedded in RDFS in such a way as to be semantically compatible with Large OWL.

This is precisely the argument that is being replayed right now. It was thought that name separation would allow complete and exact correspondence between the two semantics when ontologies were restricted to OWL DL.

This doesn't work because of domain size issues, e.g.,

Axy x=y -> pa iff qa

is "valid" in OWL Full but not in OWL DL.

(Yes, this is neither OWL Full nor OWL DL, but it illustrates the point. The OWL version is something like

ObjectProperty ( ex:s inverseOf ( ex:si ) ) ObjectProperty ( ex:q ) SubClassOf ( owl:Thing restriction ( ex:s value ( ex:spy ) ) ) Individual ( ex:spy type ( restriction ( ex:si cardinality ( 1 ) ) ) ) Individual ( ex:a type ( ex:p ) )

entails in OWL Full / does not entail in OWL DL

Individual ( ex:a type ( ex:q ) )

I believe that the name separation compromise worked into the RDF mapping was to try to achieve complete correspondence on the part of OWL DL that was rewritable as RDF. When it was shown that complete correspondence was not possible name separation was already in and never was revisited.

Ian Horrocks explains the example

It is possible in OWL to restrict the size of the domain to be 1 (or some other value) in all interpretations -- Peter uses the standard "spy point" trick to do this, by ensuring that every individual is related to the spy individual via the ex:s property and that the spy has at most one "incoming" ex:s edge (via a cardinality restriction in the inverse of ex:s).

Given such a restriction, it is obviously the case that sameAs (c d) is entailed for any two individuals c and d. In OWL Full sameAs (c d) additionally entails equivalentClass (c d), so we also get that Individual ( a type ( c ) ) entails individual ( a type ( d ) ).

We don't get this kind of entailment in OWL DL because classes are not interpreted in the same way as individuals (i.e., as elements of the domain), so for two classes c and d we would not necessarily entail equivalentClass (c d).

BTW, it seems to me that such an ontology must be inconsistent when interpreted with Full semantics because a would also be an instanced of Nothing, but this isn't relevant to the discussion.

## David Turner's Analysis

Taken from an email exchange between Alan Ruttenberg and David Turner, who was, at the time, a consultant to HP.

> From: "Turner, David" <davidt@hp.com> > Date: August 20, 2007 6:57:11 AM EDT > To: "Alan Ruttenberg" <alanruttenberg@gmail.com>, "Pat Hayes" > <phayes@ihmc.us> > Cc: "Jeremy Carroll" <jjc@hpl.hp.com> > Subject: RE: declaredAs > >> -----Original Message----- >> From: Alan Ruttenberg [mailto:alanruttenberg@gmail.com] >> Sent: 18 August 2007 06:47 >> To: Turner, David; Pat Hayes >> Subject: Re: declaredAs >> >> I'm trying to understand what the conditions on compatible >> semantics are. Clearly it isn't upward consistency, since >> everything in RDF is consistent. > > (Ignoring problems with illformed literals) > >> [what's upward, anyways? What's the relation between RDFS and OWL-Lite?] > > RDFS entailments are a subset of OWL DL entailments with respect to > the RDFS-compatible semantics of section 5 of the OWL S&AS. For > chapter-and-verse, the OWL S&AS section 5.4 says, > > [[ An OWL DL interpretation of a vocabulary V is an OWL interpretation ... ]] > > and from section 5.2, > > [[ An OWL interpretation of a vocabulary V is a D-interpretation of V that satisfies ... ]] > > and also from the RDF Model theory section 5, > > [[ If D is a datatype map, a D-interpretation of a vocabulary V is a RDFS-interpretation of ... ]] > > Thus every OWL DL interpretation is a RDFS interpretation, so that > RDFS entailments are OWL DL entailments. > >> In this example, all you've shown, it seems, is that a more >> expressive language finds an inconsistency that a weaker language >> doesn't. One can do the same thing with OWL 1.0 and RDF. > > Yes, and from a purely mathematical viewpoint, this is fine. > >> There is twist in that there's this other dimension of "syntactic >> validity". And mention of "semantic connection". >> >> What I'm looking for is a clear statement of what kinds of >> relations there are between SW languages, > > There is a strictly increasing chain of sets of entailments > > Simple <= RDF <= RDFS <= D- <= OWL DL <= OWL Full > > It was a design goal that the last strict inclusion should be an equality; see > > http://www.w3.org/2001/sw/WebOnt/webont-issues.html#I5.3-Semantic-Layering > http://lists.w3.org/Archives/Public/www-archive/2002Oct/0022.html > > In other words (subject to the syntactic constraints of OWL DL) the > entailments of OWL DL are exactly those of OWL Full. This goal > slipped a little: see > > http://www.w3.org/TR/owl-test/byFunction#function-Thing > > Tests 004 and 005 demonstrate that owl:Thing may be finite in OWL > DL but not in OWL Full. See also > > http://www.w3.org/TR/owl-test/byFunction#function-AnnotationProperty > > Tests 001 and 002 demonstrate something similar to the fact that > > <ex:a> <ex:annotationProperty> "literal" > > entails > > <ex:a> <ex:annotationProperty> _:x > _:x <rdf:type> <owl:Thing> > > in Full but not in DL. These are AIUI the *only* known failures of > the semantic connection between OWL DL and OWL Full. Note that in > some sense this semantic connection is the reason why you can use > SPARQL to talk to DL reasoners, so letting it slip too far is > undesirable. > >> some clear expression of how punning does or doesn't violate one >> of those constraints. > > The WebOnt WG charter references the OWL-1.0 issue list, of which > issue 5.3 (Semantic Layering) is a part. I take that to mean that a > design goal for OWL 1.1 is that the DL and Full semantics should be > made as close together as possible, and punning goes against that > by adding another failure of the semantic connection between DL and > Full. > >> [...] there's no precise expression of what is supposed to happen >> (according to a published specification) > > I take issue 5.3 as being exactly that expression, but as I said it > is a matter of opinion as to how seriously the new WG takes it. > > In a much earlier discussion with Bijan and co, they seemed > amenable to replacing punning with something better. They talked > about the possibility of using a Hilog-like semantics which I > believe will better serve issue 5.3 than punning will, although I > won't pretend to understand Hilog very deeply. I'm not sure whether > that still stands, but it's a possible solution that may please > everyone.

## Interaction between punning and property chains

Property_Chains describes why we can't yet support chaining punned datatype properties of object properties in property chains.

## Asymmetry between Datatype and Object properties

Jim Hendler points out that the construct

inverseFunctionalObjectProperty := 'InverseFunctionalObjectProperty' '(' { annotation } objectPropertyExpression ')

Doesn't seem to have a parallel `InverseFunctionalDataProperty`

Peter Patel-Schneider 01:21, 9 November 2007 (EST) I don't believe that this is an issue because in OWL Full all properties are object properties.

## Qualified Cardinalities in OWL 1.1 Full

Suppose that we want to keep the general flavour of the OWL Full semantics *and* use the current OWL 1.1 mapping to RDF. What would happen?

Here is an example of how the RDF mapping works (roughly).

`ObjectMaxCardinality(2 child)` expands to:

_:x rdf:type owl:Restriction

_:x owl:maxCardinality "2"^^xsd:nonNegativeInteger

_:x owl:onProperty child

`ObjectMaxCardinality(2 child Person)` expands to:

_:y rdf:type owl:Restriction

_:y owl:maxCardinality "2"^^xsd:nonNegativeInteger

_:y owl:onProperty child

_:y owl11:onClass Person

Note especially that the first set of triples is a "subset" of the second set.

The OWL 1.0 Full semantics says that the class extension of `_:x` is the set of objects that are related to at most two objects via the property extension of `child`. A similar-style OWL 1.1 Full semantics would say that the class extension of `_:y` is the set of objects that are related to at most two objects that belong to the class extension of `Person` via the property extension of `child`.

However, the OWL 1.1 Full semantics would then also include the OWL 1.0 Full semantics. So, part of the meaning of the last four triples (actually the first three of these four, but that doesn't matter) in OWL 1.1 Full would be that the class extension of `_:y` would *as well* be the set of objects that are related to at most 2 objects via the property extension of `child`.

So, if *o* is in the class extension of `_:y` then it is related to at most two objects that belong to the class extension of `Person` via the property extension of `child` *and* it is related to at most two objects via the property extension of `child`. It is impossible to have a max-QCR without this double meaning.

The solution, however, is very easy. Just use some other name besides maxCardinality, such as the DAML+OIL maxCardinalityQ.