RE: A proposal for ISSUE-104 (built-in vocabulary)

Boris Motik wrote:

>But consider the case where you use declare rdf:first as and
>owl:ObjectProperty, but your ontology also contains a nominal
>containing a literal. In the serialization of the ontology, you'll have
>_:x rdf:first "c"^^xsd:string
>but you'd also have
>rdf:first rdf:type owl:ObjectProperty.
>But then, you've just showed the constant "c"^^xsd:string into the
>individual domain. Under OWL DL semantics, your graph is now

I think, the actual problem is the reverse mapping. It would be necessary
for the reverse mapping to clearly distinguish between syntax related usage
(as in the "owl:oneOf(...)" expression), and custom usage (rdf:first as an
object property in our example). Then, the resulting FS syntax would be
something like:

  # mapping of the nominal containing a literal
  ... OneOf( ... "c"^^xsd:string ... )
  # mapping of the custom usage of rdf:first
  PropertyAssertion(rdf:first _:z ex:something)    

So in this case, the URI 'rdf:first' would exclusively occur as an object
property in the resulting FS ontology, and there would be no problem with
the semantics.

However, I am not sure whether the current reverse mapping would provide
this result. It might be (I would need to check) that, in the case that
rdf:first is an allowed URI, the reverse mapping would see the isolated

  _:x rdf:first "c"^^xsd:string

and would try to map it into a data property assertion. This would be fatal,
of course.
So the reverse mapping would perhaps need to be adjusted. 

And now, I am not convinced anymore that it is perfectly possible to have a
reverse mapping which always properly distinguishes between syntax and
custom usage. For example, the same list expression in an RDF graph (or only
a part of it) may be used both as part of the syntax and in a custom way:

    :alice rdf:type [ 
        rdf:type owl:Class ;
        owl:oneOf ( :person1 :person2 ) ]

    :alice :likes ( :person1 :person2 )

What to do here? The "canonical parsing process" in the current reverse
mapping cannot simply remove the list after the first axiom has been mapped,
since the list expression is still needed to process the second axiom. But
when list expressions are /not/ removed after the mapping of syntax use,
then I am not clear how to correctly cover the "punning-like" cases such as
the one discussed above. 

But even if it would turn out to be technically possible to always correctly
distinguish between custom and syntax usage, adjusting the reverse mapping
for handling custom use of RDF lists would perhaps significantly add to the
complexity of the RDF mapping. The reverse mapping is currently already very
complicated, and making it even more complex may lead to errors and other
To make this clear: My original idea was to introduce custom usage of RDF
lists (and reification, and ...), *if* we can get it mainly for *free*, by
just not disallowing the respective URIs. But now, I see that the cost would
probably be much higher than I expected.

So I won't push this topic any further, at least not for RDF lists (I did
not yet consider RDF reification). This looks to me as something what
/might/ be possible, but I rather tend to postpone this issue ("we currently
don't know how to do this").
>Under OWL Full semantics, it is really not clear what happens.

The situation in OWL Full is much less complicated. :)

>	Boris


>> -----Original Message-----
>> From: Michael Schneider []
>> Sent: 11 June 2008 18:16
>> To: Boris Motik
>> Cc:
>> Subject: RE: A proposal for ISSUE-104 (built-in vocabulary)
>> Hi Boris!
>> Regarding the 'rdf:first' problem: Your proposal would introduce
>> treatment for the List vocabulary in OWL 2. My own idea, stated in an
>> earlier mail, was the opposite: To simply ignore the list vocabulary
>> in those parts of the reverse mapping where it is applied as part of
>> syntax).
>> This would have the effect that rdf:first would be just some URI. And
>> would mean that, in order to use it, one would need to declare it to
>> either an owl:ObjectProperty or an owl:DatatypeProperty, respectively.
>> example, the following would then be legal OWL 2 DL:
>>   rdf:List rdf:type owl:Class .
>>   rdf:first rdf:type owl:DatatypeProperty .
>>   rdf:rest rdf:type owl:ObjectProperty .
>>   rdf:nil rdf:type owl:NamedIndividual .
>>   :alice :likesNumbers ( 2 3 5 7 ) .
>> The declarations could be imported, of course, no need to write them
>> every time.
>> It wouldn't be possible to use rdf:first both as an object and a data
>> property in the same ontology. But this is what one would expect in
>OWL 2
>> DL.
>> Michael
>> >-----Original Message-----
>> >From: [mailto:public-owl-wg-
>> >On Behalf Of Boris Motik
>> >Sent: Wednesday, June 11, 2008 12:33 PM
>> >To:
>> >Subject: A proposal for ISSUE-104 (built-in vocabulary)
>> >
>> >
>> >Hello,
>> >
>> >The discussion around ISSUE-104 (reserved vocabulary) seemed to show
>> >that lists and reification are the main, if not the only part
>> >of the reserved vocabulary that might be useful in OWL 2 DL. (If we
>> >that it is necessary, we may verify this by sending an
>> >e-mail to owl-dev once we have fleshed out our proposal. I personally
>> >don't think we need to do this, given my experience how the
>> >built-in vocabulary has been used in OWL 1.)
>> >
>> >Based on the assumption that we more or less agree on the above
>> >observation, I would like to put forward a proposal for resolving
>> >this issue. Before I do so, let me first explain why the obvious way
>> >resolving the problem does not work.
>> >
>> >
>> >1. A slight problem with exempting rdf:List from the reserved
>> >---------------------------------------------------------------------
>> >
>> >For a property to be used in any OWL 2 DL axiom, the property must be
>> >declared as either an object or a data property. Now this
>> >causes a slight problem for rdf:List: we would make a hard-and-fast
>> >choice about how to treat rdf:first. Thus, we would have to
>> >decide whether rdf:first is an object or a data property, which would
>> >essentially restrict the usage of lists in OWL 2 DL in a nasty
>> >way.
>> >
>> >
>> >2. A possible way forward
>> >-------------------------
>> >
>> >To allow for lists, we would introduce four new vocabulary elements
>> >OWL 2:
>> >
>> >- owl:List
>> >- owl:firstLiteral
>> >- owl:firstIndividual
>> >- owl:rest
>> >
>> >To ensure semantic compatibility with OWL Full, we would make
>owl:List a
>> >subclass of rdf:List, owl:firstLiteral and
>> >owl:firstIndividual a subproperty of rdf:first, and owl:rest a
>> >subproperty of rdf:rest.
>> >
>> >We would extend the structural spec to provide built-in declarations
>> >these properties (in the obvious way). We would also add a
>> >subsection to the structural spec and to the primer about how these
>> >to be used in ontologies.
>> >
>> >We would leave the rest of the built-in vocabulary in OWL 2 DL as it
>> >currently is.
>> >
>> >Note that this does not address the reification vocabulary.
>> >is considered bad in RDF anyway, and it would introduce
>> >similar problems in OWL 2 DL; therefore, it seems to me that
>> >it in OWL 2 DL is not a big deal.
>> >
>> >
>> >
>> >Let me know how you feel about this.
>> >
>> >Regards,
>> >
>> >	Boris
>> >

Received on Thursday, 12 June 2008 08:31:41 UTC