W3C home > Mailing lists > Public > public-owl-dev@w3.org > January to March 2007

RE: declaredAs

From: Pat Hayes <phayes@ihmc.us>
Date: Tue, 30 Jan 2007 12:47:09 -0600
Message-Id: <p06230908c1e540ed0398@[10.100.0.26]>
To: "Boris Motik" <bmotik@cs.man.ac.uk>
Cc: "'Michael Schneider'" <m_schnei@gmx.de>, <public-owl-dev@w3.org>, <evren@clarkparsia.com>, <matthew.horridge@cs.man.ac.uk>

Hi Boris

I have to say, this entire topic and the discussion it is engendering 
seems to me to be a good illustration of why the SWeb is better 
served by notations that do NOT require syntactic 'declarations' of 
this kind. The fact that RDF can be trivially parsed was not just 
carelessness, it was an important design decision. Our experience 
with common-logic style open syntax (which similarly removes many 
syntactic restrictions, and the concomitant need to insert 
declarations) seems to bear this out.

IMO, putting syntactic declarations into OWL 1.1 is a serious 
retrograde step, and I would urge y'all to reconsider it (though I do 
not expect Manchester to agree with me :-). It represents also a poor 
methodology for any Web design: it puts a minor software efficiency 
improvement ahead of simplicity, user convenience and learnability of 
the language.

Anyway, just a topic for the WG to discuss.

Pat

>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
>>


-- 
---------------------------------------------------------------------
IHMC		(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.	(850)202 4416   office
Pensacola			(850)202 4440   fax
FL 32502			(850)291 0667    cell
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
Received on Tuesday, 30 January 2007 18:47:20 GMT

This archive was generated by hypermail 2.3.1 : Wednesday, 27 March 2013 09:32:54 GMT