W3C home > Mailing lists > Public > public-powderwg@w3.org > September 2008

Comments on POWDER semantics last call document

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Wed, 03 Sep 2008 16:01:45 -0400 (EDT)
Message-Id: <20080903.160145.162749318.pfps@research.bell-labs.com>
To: public-powderwg@w3.org

Comments on POWDER semantics last call document
http://www.w3.org/TR/2008/WD-powder-formal-20080815/

I take POWDER to be a way of associating (arbitrary) attributed
information with (groups of) web-accessible resources.  What does this
need over base RDF (or OWL)? 
1/ It needs some way of mentioning and grouping web-accessible
   resources. 
2/ It needs some theory of attribution, i.e., what kinds of entities can
   provide information and what are their characteristics? 
3/ It may need some theory of the kinds of information that can be
   placed on these resources. 
4/ It needs some way of accessing the information, at least accessible
   from the resources themselves, but, in addition, a way of accessing the
   information directly from servers for the resources without having to
   access the resources would be useful. 

I don't see any of this necessarily "in tension" with the core semantics
of RDF and OWL.  The last is simply outside the scope of RDF and OWL, as
it involves issues related to the workings of the web, not representing
information on the web.  The second and third obviously are the kind of
thing that RDF and OWL are concerned with (although, of course, POWDER
might need more expressive power than is available in RDF or even OWL).

The mentioning and grouping of web-accessible resources is where the
most potential problems arise.  Perhaps surprisingly, RDF and OWL do not
make much of a connection between certain kinds of URI references (their
names) and web resources.  To RDF (and thus to OWL) the name (URI)
http://example.com/ is just the name of some resource, that may or may
not have any connection to whatever document can be obtained by
accessing that URI using web conventions.  Users of RDF are thus in some
sense free to use the name http://example.com/ for any purpose
whatsoever.  POWDER authors may have to take care not to combine POWDER
documents with RDF documents that do not use RDF names in the way
intended by the POWDER specification.

Further, RDF and OWL do not have any mechanism for grouping names by
their form.  To RDF (and OWL), there is no closer connection between
http://example.com/p1 and http://example.com/p2 than there is
between http://example.com/p1 and mailto:pfps@lucent.com.  POWDER
definitely has to go beyond the RDF and OWL world view to make these
connections.

The transformational approach used in POWDER, going from POWDER to
POWDER-BASE to POWDER-S, is also not necessarily "in tension" with the
core semantics of RDF and OWL, even if some tokens are given special or
exceptional treatment and even if missing information is filled in with
default values.  In particular, the treatment in Example 3-8 is
*precisely* in accord with the RDF and OWL view.  

The major problem in the document is a use-mention conflation.  The
resource referred to by http://example.com/ (which might perhaps be the
document available at http://example.com/) is (almost certainly) very
different from the URI http://example.com/ (which is definitely *not*
the document available at http://example.com/).  The first is referred
to in RDF by using the URI in a triple as in <http://example.com/>
rdf:type wdrs:WebDocument the second is referred to in RDF by using a
literal as the object (only) of a triple as in < http://example.com/>
wdrs:address "http://example.com/"^^xsd:anyURI

So what is the problem in the POWDER document?  Well the first way of
referring to sets of web-accessible documents, in Section 4.3, uses
wdrs:matchesregex, which is defined as an owl:DatatypeProperty, with
domain rdfs:Resource.  However, <x,y> is in the extension of
wdrs:matchesregex only if x is a URI (essentially a string) that matches
a regular expression.  This means that POWDER is identifying
web-accessible documents with literal URIs a use-mention conflation.

It would be much better to have a POWDER class of web-accessible
resources, each of which has (at least) one URI (that can be used to
access the resource), as in 

  Declaration(Class(wdrs:webAccessibleResource))
  Declaration(DataProperty(wdrs:hasIRI))
  Range(wdrs:accessibleVia xsd:anyURI)
  SubClassOf(wdrs:webAccessibleResource
             MinCardinality(1 wdrs:accessibleVia))

The "intended" meaning of wdrs:hasIRI is then

   <x,y> is in the property extension of wdrs:hasIRI IFF
   x is a resource that can (currently) be accessed via the IRI y 

This is similar to the treatment in Section 4.6, but it avoids 
problems there.

Then the POWDER mapping would end up with subclasses of
wdrs:webAccessibleResource whose wdrs:accessibleVia values would match
the regular expressions, using a "special" property, as in:

  Declaration(DataProperty(wdrs:hasAURIThatMatches))
  Range(wdrs:hasAURIThatMatches xsd:string)
  IntersectionOf(wdrs:webAccessibleResource
                 HasValue(wdrs:hasAURIThatMatches <regexp>))

The "intended" meaning of wdrs:hasAURIThatMatches would be

    <x,y> is in the property extension of wdrs:hasAURIThatMatches IFF 
    x has a value for wdrs:hasIRI that matches the regex y

This could then be done better using the OWL 2 data range facilities as 

  IntersectionOf(wdrs:webAccessibleResource
    SomeValueFrom(wdrs:accessibleVia 
      DatatypeRestriction(xsd:anyURI pattern <regexp>)))


Specific comments:

There appears to be some confusion in the document as to names of
built-in properties, particularly wdrs:matchesregex[p]

I would not say "semantics" so much in the document.  The document is
mostly specifing a transformation.  It is true that this then defines
the meaning of POWDER documents.  However, saying "transform" does not
give the impression that the transform *is* the semantics. 

Using a verbose syntax for OWL makes it hard to grasp the meaning of the
transform.  I think that it would be better to use TURTLE (and even
better to use the OWL 2 functional syntax or even an informal syntax
like the Manchester syntax). 

Note that the namespace associated with the ox prefix is still under
discussion in the OWL WG.   

I would suggest using TURTLE as an example of another serialization of
RDF graphs instead of N3. 

There is no notion of "null" subject in OWL.  Instead the document
appears to be referring to rdf:about="", which may or may not turn into
a node with the URI of the current document.  (Consider what happens if
there is an xml:base element in scope.)  In any case, Example 2-1
certainly does not show the attribution element being transformed into
an owl:OntologyProperty.  This section of the document needs to be fixed. 

There is no formal notion of an RDF statement being about anything.  RDF
statements have subjects, predicates, and objects. 

I am not sure what force the "SHOULD" in the issuedby section has.  RDF
is not prescriptive, so using a node as the object of a statement with
issuedby as predicate *enforces* that the object is in the range of the
property. 

The use of triple syntax requires some sort of pointer to an appropriate
definition.

Why not use XML Schema datatypes more in the transformation to RDF?

There may be a use-mention problem for certifiedby and supportedby.  If
these properties are supposed to have URIs as ranges, then rdf:resource
is not the correct kind of thing to use. 

I think that it would be a good idea to provide domains and ranges for
the POWDER properties, e.g., something like wdrs:IRISet for
wdrs:matchesregex.  I further think that there should be some sort of
true semantics document that talks about the extensions to RDF that are
used in POWDER.  This document would look something like the RDF
Semantics document or the OWL Semantics and Abstract Syntax document (or
its replacement in OWL 2).

There is no built-in OWL resource with name owl:Property.  Triples using
it should probably be removed.

Note that the value space of xsd:anyURI consists of strings, and the
lexical mapping is the identity mapping, so the use of I for anyURI
lexical values is unnecessary.  Note also that using literals as
subjects of OWL properties is only possible in OWL Full.



Peter F. Patel-Schneider
Bell Labs Research
Received on Wednesday, 3 September 2008 20:08:38 GMT

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