[Swoop] Testing metaclasses in beta Protege-OWL 3.2 vs SWOOP 2.3

[Nicolas F Rouquette]

Bernard started this charade with the issue of 2 serializations:

<owl:Class rdf:about="http://www.mondeca.com/system/onto#Person">
  ...
</owl:Class>  
<rdf:Description rdf:about="http://www.mondeca.com/system/onto#Person">
  <rdf:type>
    <owl:Class 
rdf:about="http://www.mondeca.com/system/basicontology#Class_cl"/>
  </rdf:type>
</rdf:Description>

and this serialization:

  <basicontology:Class_cl rdf:about="&onto;Person">
    <rdf:type rdf:resource="&owl;Class"/>
    ...
  </basicontology:Class_cl>

I believe the issue here is what is reasonable to expect from RDF 
parsers w.r.t. recognizing which
entities are individuals and which entities are classes. In OWL-DL, 
these two sets are disjoint.
In OWL-Full (those pesky Frenchies....), some entities are both 
instances and classes: the sets overlap.

Technically, it isn't clear that the second serialization is 100% OWL 
compliant.
There are 6 different ways to describe a class 
(http://www.w3.org/TR/owl-ref/#ClassDescription)
The second serialization seems to me a 7th different kind altogether.

It isn't a type 1 description, which would be:

<owl:Class rdf:about="http://www.mondeca.com/system/onto#Person"/>

It isn't exactly a known alternative to type 1, which would be:

<rdf:Description rdf:about="http://www.mondeca.com/system/onto#Person">
   <rdf:type rdf:resource="&owl;Class"/>
</rdf:Description>

It is *different*.

The serialization into RDF graphs defined here, 
http://www.w3.org/TR/2004/REC-owl-semantics-20040210/mapping.html,
applies to OWL-Lite and OWL-DL. For these ontologies where there is a 
separation of the resources that are
instances vs. resources that are classes, the mapping rules will produce 
RDF triples according to one of the 6 ways mentioned above.

For OWL-Full, it is unclear to me what mapping rules apply.
Without agreement on what these mapping rules should be,
it is therefore unclear what requirements are imposed on
an RDF parser to properly read an OWL-Full ontology from
a given RDF serialization.

In this case, it is clear that the second serialization involves
a small amount of 'inference' at the time of parsing:

  <basicontology:Class_cl rdf:about="&onto;Person">

When processing this, does the parser recognize basicontology:Class_cl 
as a class
such that it recognizes onto#Person as an instance instead of some other 
kind of
resource that is neither an instance nor a class?

    <rdf:type rdf:resource="&owl;Class"/>

If the parser recognized onto#Person as an instance, then this makes it 
a class
otherwise all bets are off.

  </basicontology:Class_cl>

So far, it isn't clear to me what are requirements for serializaing 
OWL-Full ontologies in RDF
in a manner that makes the serialization portable across OWL-aware RDF 
parsers. It looks like
it there is a missing void in the W3C specs on this issue.


-- Nicolas.

Bijan Parsia wrote:

>
>> * Bijan
>>
>>>> Are they strictly notational variants ore is there a missing type 
>>>> triple?
>>>
>>
>> Is this a question for me or a rhetoretical one? I don't see any 
>> missing triple, actually.
>> Just that the new serialization declare in a single place things 
>> which were before neatly
>> distinct (two aspects of the same entity).
>
>
> I was hoping that there was a substantial difference that was 
> triggering the Protege failure. If it's horking JUST on equivalent 
> serializations...well...that's a really serious problem, IMHO.
>