RE: rdfs:class versus owl:class in SOSA-Core

Antoine,
The context for all these questions is around  how to make SOSA core "simple", given that SSN is not "simple"  and "hard to use" and "too complex".  The  SOSA core is explicitly being built to be a simple part of SSN. Some reasons for simplicity relate to understanding by various users (developers, queriers, data publishers) ; some relate to complexity of formal reasoning on little devices; some just relate to what some person thinks is "usable" or not.

Having said that, the real question being stretched out here  is what do we mean by "simple".  One possible answer is that we stick to rdfs: terms so as not to scare anyone off (schema.org style) . Another possible answer  is that we permit OWL terms as well (for documentation)   but expect and advise people to use RDFS reasoning. Another is that we don't expect them to use any form of reasoning at all -- just as long as the vocabulary is unambiguously  human readable and simple they will implement it their own way. Another possible answer is we use arbitrary OWL terms just as long as (somehow)  it is less complicated than the owl-dl SSN, perhaps by demonstrating  less ontological commitment.   And for completeness I suppose the fifth possible answer is we just use SSN anyway because "simpler" is too hard.

Me -- I favour sticking to RDFS terms alone and RDFS  reasoning alone for the purpose of SOSA core. Like schema.org. Using functionally irrelevant owl: terms (even owl:Class) should be avoided because they introduce the bird into the picture  for no expressivity benefit in the RDFS reasoning scenario. Only confusion.  While (for reasons of integration with the rest of SSN) keeping within OWL-DL so that when combined with some obvious alignment axioms to the rest of SSN  it all works in OWL-DL. And if you as a user  want more than RDFS-- then just use the rest of ssn -- it is all there.

Issue-72

-----Original Message-----
From: Antoine Zimmermann [mailto:antoine.zimmermann@emse.fr] 
Sent: Thursday, 10 November 2016 8:33 AM
To: Rob Atkinson <rob@metalinkage.com.au>; Krzysztof Janowicz <jano@geog.ucsb.edu>; Joshua Lieberman <jlieberman@tumblingwalls.com>; Simon Cox <Simon.Cox@csiro.au>; Kerry Taylor <kerry.taylor@anu.edu.au>; Armin Haller <armin.haller@anu.edu.au>
Cc: SDW WG Public List <public-sdw-wg@w3.org>
Subject: Re: rdfs:class versus owl:class in SOSA-Core

[Disclaimer: I'm answering the emails in chronological order. Some things I'm saying may have been discussed in later emails that I've not yet read].


On 09/11/2016 00:47, Rob Atkinson wrote:
>
> Correct me if I'm wrong here:
>
>
> :myClass a owl:Class, rdfs:Class
>
> is the same as
>
> :myClass a owl:Class
>
> if you are using OWL reasoning.

Yes.


> If you are using RDFS reasoning (and tools like RDF4J support this) - 
> then these statements are not the same - and only the first one helps 
> you with any RDFS reasoning.

Well, it only says that :myClass is a class, nothing more. In practical situations, it's rarely useful to know that some term is a class if you don't have anything else (such as instances of the class). If you do have instances of the class, or subclass axioms, or domains or ranges using the class, then in any case the type rdfs:Class is inferred.


> So why cant we just use the first form?

+1

>
> The principle would be that the "core" would not _require_ OWL 
> reasoning to provide a RDFS model. It doenst mean we don't model in 
> OWL, just that we take on the responsibility of materialising OWL 
> entailments sufficient to allow any RDFS entailments. (Thats what I 
> mean about a "contract" with the user - being explicit about what 
> entailments are theer responsibility

To me, that makes perfect sense.


> Note that is we state:
>
> :myClass a rdfs:Class
>
> and say:
> :myClass owl:equivalentClass eg:yourClass
>
> then if you use OWL reasoning you get
>
> :myClass a owl:Class, rdfs:Class
>
> because
> owl:equivalentClass rdfs:domain owl:Class owl:equivalentClass 
> rdfs:range owl:Class

Well, this is OWL 2 RDF-based semantics. If you take the OWL 2 Direct Semantics (the one that works on OWL 2 DL ontologies [1]) literally, you can't make any inference because the input ontology is not an OWL 2 DL ontology in RDF graph form (see my former email on OWL 2 DL vs OWL 2 Full if you missed the details about this concept). But real life OWL DL reasoners do tolerate this and would understand that :myClass and eg:yourClass are both OWL classes. However, this would not be the consequence of rdfs:domain and rdfs:range at all.

>
> Therefore, if you don't explicitly state its an owl:Class you can 
> still do OWL reasoning and you have lost nothing - but if you don't 
> explicity state its and RDFS class then you wont get the full RDFS 
> expressible semantics  without OWL reasoning.
>
> statements such as owl:inverseOf are just documentation for RDFS 
> interpretations, and perhaps "do no harm"?
>
> am I missing something here?

I agree but will happily read the arguments against this.


> note that we can then have sosa-owl-dl  and other OWL flavours as 
> vertical modules that require OWL reasoning to be fully understood.


[1] Boris Motik, Peter F. Patel-Schneider, Bernardo Cuenca Grau. OWL 2 Web Ontology Language, Direct Semantics (Second Edition). W3C Recommendation 11 December 2012. 
https://www.w3.org/TR/2012/REC-owl2-direct-semantics-20121211/


--AZ


>
> Rob Atkinson
>
>
>
>
> On Wed, 9 Nov 2016 at 10:01 Krzysztof Janowicz <jano@geog.ucsb.edu 
> <mailto:jano@geog.ucsb.edu>> wrote:
>
>     Hi,
>
>     Sorry for being so picky about this during our meeting but I do not
>     want us to take decisions that have consequences that we can not yet
>     foresee.
>
>     To the best of my knowledge (and please correct me if I am wrong):
>
>     Under the semantics of OWL1, rdfs:class and owl:class are only
>     equivalent for OWL-Full. For OWL-DL (and OWL-Lite) owl:class is a
>     subclass of rdfs:class.
>
>     This means that every valid document in OWL will be a valid document
>     in RDFS, however *not* every rdfs:class is an owl:class. I do not
>     want us to end up in OWL-Full because of this.
>
>     For OWL2, I found this: 'owl:Class rdfs:subClassOf rdfs:Class . "
>     (https://www.w3.org/TR/owl2-rdf-based-semantics/). Things may be
>     more complicated here due to OWL2 punning and they may well turn out
>     to be equivalent, I will check this later.
>
>     If we decide to restrict ourself to only using RDFS for SOSA-core,
>     and I am not in favor of this, then we may have to go with
>     rdfs:class. However, we have not yet taken this decision and have
>     also not discussed which axioms and language to use for SSN. As
>     Sosa-core and SSN will be aligned, this may have more consequences
>     that we should consider. It also seems like many of us are in favor
>     of using inverseOf, so we would be using OWL (and its formal
>     semantics) anyway. Note that this does not do any harm to an
>     RDFS-only tool/user as for those the inverseOf axiom will simply
>     have no formal semantics. Still all other triples that use both
>     relations will still be just fine.
>
>     Given the subclasssing, I do not see any problems using owl:class,
>     but we may accidentally end up in OWL-full or with being
>     incompatible to the standards if we opt for rdfs:class. Again, I am
>     happy to be corrected. At least, I do not see harm in simply using
>     owl:class.
>
>     Finally, and from very pragmatic point of view: ontologies that are
>     under very heavy use such as the DBpedia ontology simply use
>     owl:class and I have not yet seen any issues or complaints about
>     that. See, for example, http://dbpedia.org/ontology/City

>     "dbo:City    rdf:type    owl:Class ." The same is true for the
>     goodrelations ontology and so forth (but I admit that this is due to
>     the more complex axiomatization they use).
>
>     I hope this will start a productive discussion.
>
>     Thanks for reading,
>     Krzysztof
>
>

Received on Wednesday, 9 November 2016 22:33:00 UTC