W3C home > Mailing lists > Public > www-webont-wg@w3.org > April 2002

RE: SEM: semantics for current proposal (why R disjoint V?) (sameState TEST)

From: Jeremy Carroll <jjc@hplb.hpl.hp.com>
Date: Mon, 29 Apr 2002 22:14:22 +0100
To: "Ian Horrocks" <horrocks@cs.man.ac.uk>, "Dan Connolly" <connolly@w3.org>
Cc: "Pat Hayes" <phayes@ai.uwf.edu>, <www-webont-wg@w3.org>
Message-ID: <JAEBJCLMIFLKLOJGMELDCEOBCDAA.jjc@hplb.hpl.hp.com>
> Unfortunately, the interaction of UnambiguousProperty and datatypes
> makes this problematical. Imagine, for example, that a datatype
> consisting of integers in the range 0-999 is used as a unique-id/key
> for instances of the class Person such that all persons have exactly
> one unique-id, all unique-ids are integers in the range 0-999, and
> unique-id is an UnambiguousProperty.  In order to function correctly,
> a reasoner is now required to understand the properties of datatypes,
> e.g., that the cardinality of this particular datatype is 1,000, and
> that as a result no model can contain more than 1,000 instances of
> Person (note that this would not be the case if unique-ids were reals
> in the range 0-999).

Can't I set up this example without any recourse to datatypes at all.

e.g.

I form one thousand URIs.
For each one I form the class: oneOf[x] (giving me 1000 classes).

I form the disjoint union of these 1000 classes, giving me oneOf 1000
distinct URIs.

i.e.

<daml:Class rdf:ID="Thousand">
  <daml:disjointUnionOf rdf:parseType="daml:collection">
    <daml:Class>
      <daml:oneOf rdf:parseType="daml:collection>
        <rdf:Description rdf:about="#000"/>
      </daml:oneOf>
    </daml:Class>
    <daml:Class>
      <daml:oneOf rdf:parseType="daml:collection>
        <rdf:Description rdf:about="#001"/>
      </daml:oneOf>
    </daml:Class>
...
    <daml:Class>
      <daml:oneOf rdf:parseType="daml:collection>
        <rdf:Description rdf:about="#999"/>
      </daml:oneOf>
    </daml:Class>
  </daml:disjointUnionOf>
</daml:Class>


I now define an UnambiguousProperty whose range is that Thousand class

<daml:UnambiguousProperty rdf:ID="p">
   <daml:range rdf:resource="#Thousand"/>
</daml:UnambiguousProperty>

>
> The formal properties of the resulting logic are not well understood
> (e.g., it is not clear yet if the language would be
> decidable).

pass

>  Moreover, it would cause severe problems for implementors
> and might be a source (admittedly not the only possible source) of
> crippling intractability: remember that, unlike a database, the
> existence of 2,000 individual names would not be an error, but would
> lead to the inference that the names must be partitioned into 1,000
> sets of "sameIndividuals". Check out the number of ways that 2,000
> elements can be partitioned into 1,000 sets - it is a big number!

snap?

>
> This is an irresistible opportunity for a very nice citation [1] :-).
> Sadly, Stirling does not seem to have made this work available on
> his web site.
>
> Regards, Ian
>
> [1] Stirling, J. Methodus differentialis, sive tractatus de summation
> et interpolation serierum infinitarium. London, 1730. English
> translation by Holliday, J. The Differential Method: A Treatise of the
> Summation and Interpolation of Infinite Series. 1749.

Jeremy
Received on Monday, 29 April 2002 17:14:38 GMT

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