Re: using owl:restrictions

On Feb 19, 2006, at 11:47 AM, PL. Miraglia (home) wrote:

> You're right, I had left out a lot of assumptions that I thought could
> be filled out in the most "obvious" manner, but that's probably bad
> practice -- when one is asking for clarifications especially!

It matters a lot if you are trying to move between OWL Full and OWL DL,  
hence the need for details.

> So I'll try to be more specific below.  Let me say that this was just
> for clarifying to myself the meaning of Owl expressions, and their
> relations to FOL style KR.  I had no particular application in mind.

I recommend:
	<http://www.cs.man.ac.uk/~horrocks/Publications/download/2003/ 
HoPH03a.pdf>

For a good discussion.

For OWL DL, there is a direct transliteration to FOL via the  
transliteration to SHOIN.

> So your reply is already helpful.  But onto the particulars:
> On 2/18/06, Bijan Parsia <bparsia@isr.umd.edu> wrote:
>> On Feb 18, 2006, at 3:01 PM, PL. Miraglia (home) wrote:
>>
>>> consider the following:
>>>
>>> <rdfs:subClassOf>
>>>    <owl:Restriction>
>>>       <owl:onProperty rdf:resource="#R"/>
>>>       <owl:someValuesFrom rdf:resource="#P"/>
>>>    </owl:Restriction>
>>>    <owl:Class rdf:about="#Q"/>
>>> </rdfs:subClassOf>
>>>
>>> I need some clarifications about this term: are these statements true
>>> or false?
>>>
>>> 1) The construct above is legal in OWL DL/Full not OWL Lite -- right?
>>
>> FIrst I want to ask why do you care? It's relatively important to
>> distinguish between OWL Full and OWL DL, but much less so for OWL Lite
>> and OWL DL. Anyhoo.
>
> I am not interested in the DL/Lite distinction, actually.  I was most
> curious about: can a restriction be the subject of a subClassOf axiom
> too?

Yes it can, but that would be (syntactically) in OWL DL. See:

	<http://www.w3.org/TR/owl-semantics/syntax.html#2.3.2>

In particular, these productions:

axiom ::= ...
         | 'SubClassOf(' description description ')'

description ::= classID
             | restriction
	  ....

In OWL lite you'd have to use an intermediate name due to the  
restriction to atomic names on the LHS of conditionals, but it's  
perfectly possible, e.g.,

A = some(P, C).
A subClassOf D

(clearly these imply some(P,C) subClassOf D).

> It's not commonly seen, but it seems to me that it's perfectly
> legal -- also it would help dispensing with having to use inverse
> relations for everything, which I find kinda silly.)

I don't see how inverses were helping, but yes, you can write arbitrary  
GCIs in OWL. Swoop can handle these easily and even has special support  
for what you're doing here.

>> This fragment alone (assuming a reasonable outer wrapping element)  
>> will
>> be owl full because of the lack of type triples for #R and #P  
>> (probably
>> objectproperty and class).
>
> Right. I didn't mean this fragment to be "alone", but I didn't bother
> to add the necessary definitional axioms.  I guess i was assuming at
> least this:
[snip since fullness isn't the issue, and a bit more]

>> Oh, and it's illegal RDF as it will have two object elements as the
>> value of one property element.
>>
>> You may have meant something like this:
>>
>> <owl:Class rdf:about="#A">
>>         <rdfs:subClassOf>
>>            <owl:Restriction>
>>                      <owl:onProperty rdf:resource="#R"/>
>>                     <owl:someValuesFrom rdf:resource="#P"/>
>>                 </owl:Restriction>
>>         </rdfs:subClassOf>
>>         <rdfs:subClassOf>
>>                 <owl:Class rdf:about="#Q"/>
>>         </rdfs:subClassOf>
>> </owl:Class>
>
> This is not what I meant. Logically, it defines a class A that is (a
> subset of) the intersection of the set {x: Ey(Rxy & Py)} and Q.  What
> I was trying to express is instead:
>
> {x: Ey(Rxy & Py)} is a subset of Q


Ah, but you seem to think that prefix is the way to do it. It's not.  
subClassOf is always infix:

  <owl:Restriction>
	<owl:onProperty rdf:resource="#R"/>
          <owl:someValuesFrom rdf:resource="#P"/>
	<rdfs:subClassOf rdf:resource="#Q"/>
</owl:Restriction>

Or
  <owl:Restriction rdf:nodeID="foo">
	<owl:onProperty rdf:resource="#R"/>
          <owl:someValuesFrom rdf:resource="#P"/>
</owl:Restriction>

<rdf:Description rdf:nodeID="foo">
	<rdfs:subClassOf rdf:resource="#Q"/>
</rdf:Description>	


So, in Swoop, I created a class Q (and the relevant properties and  
other classes), turned on Editable, and then clicked on "add  
Superclass" and made the restriction and it came out:

<owl:Restriction>
     <rdfs:subClassOf rdf:resource="#Q"/>
     <owl:onProperty rdf:resource="#P"/>
     <owl:someValuesFrom rdf:resource="#D"/>
   </owl:Restriction>

Pretty easy.

[snip]

> I was trying to figure how to express in owl these 2 logical
> constraints on an arbitrary property (binary predicate) R:
>
> 1. (Ex)(Rxy & Qx) => Py
>
> 2. (Ey)(Rxy & Py) => Qx

	<http://www.mindswap.org/dav/ontologies/bijan/2006/examples/owl-dev 
-2006-feb>

does both.

> (1) is straightforward in owl (or so I thought, perhaps I am wrong  
> there too):
>
> <owl:Class rdf:about="#Q>
>    <rdfs:subClassOf>
>       <owl:Restriction>
>          <owl:onProperty rdf:resource="#R"/>
>          <owl:allValuesFrom rdf:resource="#P"/>
>       </owl:Restriction>
>    </rdfs:subClassOf>
> </owl:Class>

That gives you Qx => (Ey)(Rxy & Py). See my file for the correct  
encoding.

And didn't you mean "someValuesFrom"?

> (2) is the one I have a question about.  It seems that it can be
> expressed in the "straightforward" form of (1), provided that IR (the
> inverse of R) is used.

Hmm. I missed the swap of the variables.. Yes, you need an inverse in  
order to bind the first argument of a property with a nested  
quantifier.

> But is the inverse necessary?

Yes. And, unfortunately, in owl you don't have an inverse operator (as  
is standard in DLs), so you have to coin a name for the inverse. Curse  
RDF! :)

Cheers,
Bijan.

Received on Sunday, 19 February 2006 17:36:38 UTC