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

On 09/11/2016 15:51, Kerry Taylor wrote:
> There is another thing going on here. As soon as you **do** something
> with a Class in RDF it becomes an rdfs:Class anyway  e.g. :a rdf:type
> :B  means immediately that rdfs infers that  :B rdf:type rdfs:Class (and
> similarly for subclass assertions).  So, replacing :myClass in place of
> :a above, and owl:Class in place of :B, ie, writing :myClass rdf:type
> owl:Class , means that indeed  an rdfs reasoner would infer  :myClass
> rdf:type rdfs:Class.

Hmm, sorry, no. What you get from the rule you cite and the triple:

  :myClass  a  owl:Class .

is that:

  owl:Class  a  rdfs:Class .

which is not really satisfying.



--AZ


>
> See https://www.w3.org/TR/rdf-schema/#ch_type
>
> Which says that indeed every owl class is also an rdfs class in rdfs
> semantics --- but for a different reason.
>
> ØIt is not necessarily a problem to use [:myClass a owl:Class,
> rdfs:Class] but it is redundant.
>
> Agreed, now.
>
> ØI would also point out that many of those looking for a simple
> class-property based vocabulary do not really engage in any
> (machine-based) reasoning, rdfs or otherwise. They mostly want a
> controlled vocabulary and links that their software can rely on.
>
> So let’s not scare them off by suggesting they need reasoning by our use
> of owl: terms in our core.
>
> ISSUE-72
>
> Kerry
>
> *From:*Joshua Lieberman [mailto:jlieberman@tumblingwalls.com]
> *Sent:* Thursday, 10 November 2016 1:00 AM
> *To:* Rob Atkinson <rob@metalinkage.com.au>
> *Cc:* Krzysztof Janowicz <jano@geog.ucsb.edu>; Simon Cox
> <Simon.Cox@csiro.au>; Kerry Taylor <kerry.taylor@anu.edu.au>; Armin
> Haller <armin.haller@anu.edu.au>; SDW WG Public List <public-sdw-wg@w3.org>
> *Subject:* Re: rdfs:class versus owl:class in SOSA-Core
>
> It would be helpful for those with more experience in rdfs reasoners to
> chime in here, but I don’t think that it is necessary to use owl
> reasoning over owl:class, just use rdfs reasoning that it (and anything
> declared as that type, e.g. myns:myClass) is “rdfs:subClassOf”
> rdfs:Class. It is not necessarily a problem to use [:myClass a
> owl:Class, rdfs:Class] but it is redundant.
>
> I would also point out that many of those looking for a simple
> class-property based vocabulary do not really engage in any
> (machine-based) reasoning, rdfs or otherwise. They mostly want a
> controlled vocabulary and links that their software can rely on.
>
> Josh
>
>     On Nov 9, 2016, at 3:31 AM, Rob Atkinson <rob@metalinkage.com.au
>     <mailto:rob@metalinkage.com.au>> wrote:
>
>     AFAICT  "However, not every rdfs class is an owl class. "
>
>     doesnt change the logic of requiring explicit rdfs:Class
>     declarations in the core so users dont need to use OWL reasoners to
>     do RDFS reasoning
>
>     On Wed, 9 Nov 2016 at 16:58 Joshua Lieberman
>     <jlieberman@tumblingwalls.com <mailto:jlieberman@tumblingwalls.com>>
>     wrote:
>
>         Since owl:Class rdfs:subClassOf rdfs:Class, then any owl class
>         is also an rdfs class. However, not every rdfs class is an owl
>         class.
>
>             On Nov 8, 2016, at 6:47 PM, Rob Atkinson
>             <rob@metalinkage.com.au <mailto:rob@metalinkage.com.au>> 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.
>
>             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.
>
>             So why cant we just use the first form?
>
>             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
>
>             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
>
>             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?
>
>             note that we can then have sosa-owl-dl  and other OWL
>             flavours as vertical modules that require OWL reasoning to
>             be fully understood.
>
>             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:32:06 UTC