RE: declaredAs

Hello,

> -----Original Message-----
> From: Michael Schneider [mailto:m_schnei@gmx.de]
> Sent: 30 January 2007 17:46
> To: bmotik@cs.man.ac.uk
> Cc: public-owl-dev@w3.org; evren@clarkparsia.com;
> matthew.horridge@cs.man.ac.uk
> Subject: RE: declaredAs
> 
> Hi, Boris!
> 
> I did not know about this new feature of "declarations", so I read
> chapter 8 of the current OWL1.1 draft [1]. A few questions arise, both
> from the draft, and from this discussion.
> 
> Boris Motik wrote on Fri, 26 Jan 2007:
> 
> > There is a big difference between (2) and (3): (3) is used to detect the
> > type of P, whereas (2) is used to detect whether P has been explicitly
> > declared. Note that (2) implies (3), but not the other way around:
> 
> Does (2), a declaredAs statement, really imply (3), a rdf:type axiom? Or
> is this just a typo?
> 
> Say, we have the following ontology:
> 
>    :Man rdf:type owl:Class .
>    :Woman rdf:type owl:Class .
>    :Man owl:disjointWith :Woman .
>    :peter rdf:type :Man .
> 
> Without any other axioms, this ontology is satisfiable (has a model).
> 
> Now, if there is an additional declaration
> 
>    :peter owl11:declaredAs :Woman .
> 

This is an invalid triple. Declarations could be used only to emphasize that
:peter is an individual. Hence, you might write something like

    :peter owl:declaredAs owl:Individual.

Declarations are entirely metalogical. Now there might have been a slight
misunderstanding regarding the meaning of "implies" in the sentence
mentioned below. "Implies" here is meant in no semantic sense, and it is not
meant to imply existence of RDF triples. What we meant in the discussion is
the following: the above statement allows you to deduce that :peter is an
owl:Individual. Thus, when you parse thus ontology, if you encounter some of
the OWL 1.0 untyped syntax in which :peter occurs, then you can conclude
that :peter is an individual in this case.


> and if (2) implies (3), then we can conclude that the additional typing
> statement
> 
>    :peter rdf:type :Woman .
> 
> holds. Our ontology has become (semantically) inconsistent: The ontology
> is not satisfiable anymore, so every interpretation, which has been a
> model before, isn't a model anymore after adding the declaration.
> 
> But the draft says:
> 
>    "a declaration is a kind of axiom [...] but it imposes no constraints
>    on the model-theoretic interpretation of an ontology"
> 
> So, the above semantical change should /not/ have happened by just
> adding a declaration. Is this right?
> 

The draft is OK. Declarations are purely metalogical. The confusion between
owl:declaredAs and rdf:type is simply arising because rdf:type has been
overloaded in OWL 1.0:

- It was used to state that some object exists in the ontology.
- It was used to state the "lexical type" of an object; that is, it was used
to disambiguate URIs during parsing.
- It was used to convey semantical information.

Now in OWL 1.1, we wanted to distinguish these cases as cleanly as possible,
on order to be capable of restoring the contents of the knowledge base
precisely. Note that all this gets very complex if you also have imports:
declarations for entities might be contained in your imported ontologies.

Hence, we have in OWL 1.1 the following:

- To state that something exists in an ontology, we have owl:declaredAs.
- To disambiguate the lexical type of an object and to be able to parse the
old untyped OWL 1.0 constructs, we have

:x rdf:type owl:Class | owl:DataProperty | owl:ObjectProperty | etc.

We chose not to change this in order to be compatible with OWL 1.0 as much
as possible.

- As in OWL 1.0, you state class membership using

:x rdf:type :myClass

> Thus, I assume it's really meant that (3) implies (2), not the other way
> around. Or did I misunderstand something here?
> 

Implication is not meant to be "logically implies" or "implies existence of
a triple". Probably it was wrong of us to use this term at all in our
discussion. We simply meant that seeing a triple

:x owl:declaredAs owl:Class

is the same as seeing a triple

:x rdf:type owl:Class.

That is, from either of these two triples you can deduce that the "lexical
type" of :x is owl:Class, so, when you parse an OWL 1.0 untyped syntax, you
know the type of :x.

> > Hence, there indeed is a
> > need to distinguish the two if you are to completely recover the state
> of
> > the original ontology upon loading.
> 
> I can see that declarations and typing axioms are different features:
> Declarations are meant to have no semantical implications at all, while
> typing axioms actually have. But I do not see yet, why declarations are
> really an important feature from a /practical/ point of view.
> 
> For instance, section 8.2 of the draft contains the following example:
> 
>    Ontology(<http://www.my.domain.com/example>
>      SubClassOf( Human Animal )
>    )
> 
>  From the definition of "structural consistency" (later in the text)
> 
>    "An ontology O is structural consistent if each entity occuring
>    in an axiom from the axiom closure of O is declared in O".
> 
> I can see that the above ontology is /not/ structural consistent: There
> is no declaration for 'Human' and 'Animal'. But when is this a problem?
> 
> Please do not consider this question as a trial to flame. :) I probably
> simply do not see a real usecase, because it is the first time I am
> dealing with declarations. But currently I am asking myself, who is
> going to use such declaration statements, instead of simply (ab)using
> rdf:type axioms for this purpose, as it is always done in OWL1.0.
> 
> BTW: In the above example, I can at least infer from the subclass-axiom
> that
> 
>    :Human rdf:type owl:Class .
>    :Animal rdf:type owl:Class .
> 
> So, if (3) really implies (2), as I believe (see above), than we
> actually /have/ declarations for ':Human' and ':Animal'. In this case,
> IMHO another example should be put into the draft.
> 
> But please correct me if I am totally miss the point here (quite
> possible)!
> 
> 
> Cheers,
> Michael
> 
> [1] OWL1.1 draft, "Declarations and Structural Consistency"
>      http://owl1-1.cs.manchester.ac.uk/owl_specification.html#8
> 

I hope that this now clarifies any confusion.

Sincerely yours,

	Boris

> >
> > Sincerely yours,
> >
> > 	Boris
> >
> >> -----Original Message-----
> >> From: Evren Sirin [mailto:evren@clarkparsia.com]
> >> Sent: 26 January 2007 15:22
> >> To: Boris Motik
> >> Cc: 'Matthew Horridge'; public-owl-dev@w3.org
> >> Subject: Re: declaredAs
> >>
> >> On 1/26/07 6:27 AM, Boris Motik wrote:
> >> > Hello,
> >> >
> >> > Well, we've been thinking about this, but decided not to do so for an
> >> > important reason. Consider an ontology O containing an object
> property P
> >> for
> >> > which there is no declaration. A serialization of O into an RDF graph
> >> must
> >> > ensure the following two things:
> >> >
> >> > (1) When you parse the graph, you must be able to decode the type of
> P.
> >> > (2) The parsing should correctly restore the "declaredness" status of
> P
> >> --
> >> > that is, after parsing, the ontology should not contain a declaration
> >> for P.
> >> >
> >> > Now the problem is that, to ensure compatibility with OWL DL, we use
> >> > rdf:type to ensure (1). In the worst case, you really need to include
> a
> >> > triple
> >> >
> >> > (3) <P, rdf:type, owl:ObjectProperty>
> >> >
> >> > so that, when you parse the graph, you know what the type of P is.
> But
> >> then,
> >> > you should not use rdf:type to reflect the "declaredness" status of P
> in
> >> an
> >> > ontology; otherwise, any ontology that contains the triple (3) will
> also
> >> > contain a declaration for P.
> >> >
> >> Boris, could you explain a little why (2) is needed in the first place.
> >> What kind of problems arise if the ontology after parsing contains a
> >> declaration for P? If the type of P will be decoded as ObjectProperty
> in
> >> the end, having (3) seems harmless.
> >>
> >> Thanks,
> >> Evren
> >>
> >> > We weren't able to find a way out of this problem and have,
> >> consequently,
> >> > introduced the owl:declaredAs property.
> >> >
> >> > Thanks anyway for this suggestion!
> >> >
> >> > Sincerely yours,
> >> >
> >> > 	Boris
> >> >
> >> >
> >> >> -----Original Message-----
> >> >> From: public-owl-dev-request@w3.org [mailto:public-owl-dev-
> >> request@w3.org]
> >> >> On Behalf Of Matthew Horridge
> >> >> Sent: 26 January 2007 10:06
> >> >> To: public-owl-dev@w3.org
> >> >> Subject: declaredAs
> >> >>
> >> >>
> >> >> All,
> >> >>
> >> >> I've been working on an OWL 1.1 parser/renderer recently, and I
> >> >> wondered if we could just use rdf:type instead of owl:declaredAs for
> >> >> entity declarations in the RDF mapping.  I can't immediately see a
> >> >> problem with doing this, and I believe it would improve backwards
> >> >> compatibility with the existing "OWL 1.0" RDF/XML mapping.  Any
> >> >> thoughts?
> >> >>
> >> >> Cheers,
> >> >>
> >> >> Matthew
>

Received on Tuesday, 30 January 2007 18:05:22 UTC