W3C home > Mailing lists > Public > www-webont-wg@w3.org > May 2003

Issue 3.2 QCR: proposal to POSTPONE

From: Guus Schreiber <schreiber@cs.vu.nl>
Date: Wed, 07 May 2003 16:45:42 +0200
Message-ID: <3EB91C16.6080708@cs.vu.nl>
To: WebOnt WG <www-webont-wg@w3.org>


Per my action of the May 1 telecon, I have written a short section for
Guide on QCRs [1]. It is written as an extension to the current scheme, so
we have some redundancy now (as Pat showed [2] all restrictions can be
expressed as qualified restrictions). I have added a brief note on a
general syntax without taking history into account, just for
information, building on Jeremy;s
and Ian's examples. As it is a Guide section, it only contains
RDF/XML syntax, but Ian's message [3] already provides pointers to 
changes required for the abstract syntax

Although I've written the Guide section, I'm proposing to POSTPONE
this issue for the following reasons:

1. OWL already contains one QCR construct: owl:someValuesFrom (QCR
    with minimal cardinality of 1) which covers some
    frequent-occurring cases of QCRs.

2. There are some workarounds for QCRs, using the rdfs:subPropertyOf
    construct.  These can be used in simple cases, such as the example
    in the Guide below. The WG agrees that these workarounds are more
    problematic for complex part-of relations such as pointed out by
    Alan Rector in his use cases a) and b).[4]

3. The evidence on whether users need this is mixed. Rector's use cases
    are compelling, but Protege (which has a large user community) has
    not reported user requests for this feature.

4. Inclusion of this feature will put additional burden on
    implementations. For example, it is nontrivial to add this to
    Protege.

The Working Group therefore POSTPONES the full treatment of QCRs,
while considering possibilities for making idioms or other guidelines
for QCRs available to the community.

Guus

[1] 
http://www.w3.org/2001/sw/WebOnt/webont-issues.html#I3.2-Qualified-Restrictions
[2] http://lists.w3.org/Archives/Public/www-webont-wg/2003Apr/0087.html
[3] http://lists.w3.org/Archives/Public/www-webont-wg/2003Apr/0176.html
[4] 
http://lists.w3.org/Archives/Public/public-webont-comments/2003Apr/0040.html


--------------------------------------
Possible wording for QCR in OWL Guide
--------------------------------------

Notes:
- I used a simpler Italian-meal example, otherwise the examples would
   have become overly complex. Sorry, Jeremy.
- RDF/XML syntax of examples has not been checked yet.


QUALIFIED CARDINALITY RESTRICTIONS

The cardinality restrictions we discussed so far restrict the number
of values, irrespective of the value type. For example, we can
state, that a minimal Italian dinner contains exactly three courses:

<owl:Class rdf:ID="MinimalItalianDinner">
   <rdfs:subClassOf>
     <owl:Restriction>
       <owl:onProperty rdf:resource="#hasCourse"/>
       <owl:cardinality 
rdf:datatype="&xsd;nonNegativeInteger">3</owl:cardinality>
     </owl:Restriction>
   </rdfs:subClassOf>>
</owl:Class>

However, suppose we wanted to add the following restrictions for
minimal Italian dinners:

   * The dinner must include exactly one "antipasto" (starter)
   * The dinner must include exactly one "dolce" (dessert)
   * The dinner must include exactly one of either "primo piatto"
     (first dish) or "secondo piatto" (second dish).

       NOTE for the WG: I know that some Italian restaurants in the States
       consider you a dummy when you skip either primo or secondo, but
       it is quite common in contemporary Italy.
       END NOTE

Thus, we need a way of saying that the number of values OF A
PARTICULAR TYPE (e.g., a starter) is restricted (e.g., to 1).  We call
these "qualified cardinality restrictions", where the term "qualified"
means that we do not express restrictions on the overall number of values
of a property, but only on the number of values of a certain type
(i.e., class, datatype).

OWL includes an alternative restriction class for qualified
cardinality restrictions, namely owl:QualifiedRestriction. Here is the
example restriction for the antipasto:

<owl:Class rdf:about="#MinimalItalianDinner">
   <rdfs:subClassOf>
     <owl:QualifiedRestriction>
       <owl:onProperty rdf:resource="#hasCourse"/>
       <owl:valuesFrom rdf:resource="#Antipasto"/>
       <owl:cardinality 
rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
     </owl:QualifiedRestriction>>
   </rdfs:subClassOf>>
</owl:Class>

Qualified restrictions look very much like regular restrictions,
but, whereas the latter only contain two triples (an owl:onProperty one
and some constraint such as owl:allValuesFrom or owl:cardinality),
qualified restrictions contain three triples, namely:

   1. owl:onProperty, pointing to the property concerned
   2. owl:valuesFrom, pointing to the value type being restricted
   3. a cardinality constraint (owl:cardinality, owl:minCardinality or
      owl:maxCardinality), which restricts the number of values
      the property can take for this type

     NOTE (only in REF?): the observant reader may have noticed that
     the owl:someValuesFrom construct discussed earlier is actually a
     qualified restriction in disguise. It is equivalent to a qualified
     cardinality restriction with a minimal cardinality of 1.

The other example restrictions on MinimalItalianDinner can be
expressed in a similar way (see the food.owl file).

Qualified cardinality restrictions are common when expressing part-of
relations. For example, the hand contains five fingers, one of which
is a thumb. For wine, a typical example would be to constrain the
grape types in a wine. Suppose we want to define that an Italian Chianti
wine should contain the Sangiovese grape (but typically contains other
grape types as well). This could be specified as follows:

<owl:Class rdf:about="ChiantiWine">
   <rdfs:subClassOf>
     <owl:QualifiedRestriction>
       <owl:onProperty rdf:resource="#hasGrape"/>
       <owl:valuesFrom rdf:resource="#Sangiovese"/>
       <owl:cardinality 
rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
     </owl:QualifiedRestriction>>
   </rdfs:subClassOf>>
</owl:Class>



---- END OF TEXT FOR GUIDE  ------

NOTE

If we had to design this this without a history, I would have preferred the
following basic scheme with three types of restrictions:

1. owl:CardinalityRestriction

- Constrains the number of range values, independent of the type of value
- Has two triples:
   * exactly one owl:onProperty triple
   * exactly one owl:minCardinality,owl:maxCardinality or
     owl:cardinality triple.

2. owl:ValueRestriction

- Constrains the type of range values, independent of the number of
   values
- Has two triples:
   * exactly one owl:onProperty triple
   * exactly one owl:valuesFrom triple

3. owl:ValueCardinalityRestriction (owl:QualifiedRestriction)

- Constraints the number of range values for a certain type
- Has three triples:
   * exactly one owl:onProperty triple
   * exactly one owl:minCardinality, owl:maxCardinality or
     owl:cardinality triple.
   * exactly one owl:valuesFrom triple

Notes:
- there is no allValuesFrom in this scheme. We can just use
   "valuesFrom" as its use is now unambiguous. We could stick to
   allValuesFrom, if people think that is clearer.
- there is also no someValuesFrom, as it can be expressed with
   as an owl:ValueCardinalityRestriction with minCardinality=1. Keeping
   it as a shorthand could be confusing.

The advantage of this scheme for me is that it is really easy to
explain.




-- 
NOTE: new affiliation per April 1, 2003

Free University Amsterdam, Computer Science
De Boelelaan 1081a, 1081 HV Amsterdam, The Netherlands
Tel: +31 20 444 7739/7718
E-mail: schreiber@cs.vu.nl
Home page: http://www.cs.vu.nl/~guus/ [under construction]
Received on Wednesday, 7 May 2003 10:45:47 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:58:00 GMT