W3C home > Mailing lists > Public > www-rdf-logic@w3.org > October 2000

DAML-ONT: RDF syntax

From: Sergey Melnik <melnik@db.stanford.edu>
Date: Tue, 24 Oct 2000 14:51:12 -0700
Message-ID: <39F60450.166664E3@db.stanford.edu>
To: www-rdf-logic@w3.org, Dan Connolly <connolly@w3.org>
(The information provided below reflects the opinion of the Stanford
DAML team.)

The DAML-ONT specification posted on daml.org has several deficiences
with respect to the RDF syntax. 

I made several minor syntactic changes to the specification to ensure
that available RDF tools (like [1]) can process it correctly. Both the
new version of the spec and the SED script I used are appended.

I'd recommend to DAML participants to consider the following syntactic
issues while working on the "homework" assignments and using DAML-ONT.
Example:

Original definition:

	<Property ID="subClassOf">
	  <equivalentTo
resource="http://www.w3.org/2000/01/rdf-schema#subClassOf"/>
	</Property>

	Deficiencies:
	  - invalid RDF syntax: attributes "ID" and "resource" are not
qualified and
	    won't be recognized by all RDF parsers.
	  - the definition is location-dependent. If the DAML/RDF file is moved
to another location
            (e.g. stored on a local disk), it will break.
	  - including full resource URIs is time consuming and error-prone.

Better definition:

	<Property rdf:ID="&daml-o;subClassOf">
	  <equivalentTo rdf:resource="&rdfs;subClassOf"/>
	</Property>

	This definition requires declaration of corresponding XML entities on
the top of the document
	(see appended daml-o.rdf specification).


When in question, please always use fully-qualified tag names and
attributes in your DAML/RDF files. Similarly, try to avoid relative
references to locally defined resources. For example,

	<complementOf rdf:resource="&daml-o;Thing"/>

is superior to

	<complementOf resource="#Thing"/>

The amended spec is also available as
http://www-db.stanford.edu/~melnik/daml/daml-o.rdf


Sergey Melnik & Stanford DAML team

[1] http://www-db.stanford.edu/~melnik/rdf/api.html
<?xml version="1.0"?>

<!DOCTYPE rdf:RDF [
 <!ENTITY daml-o "http://www.daml.org/2000/10/daml-ont#">
 <!ENTITY rdf    "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
 <!ENTITY rdfs   "http://www.w3.org/2000/01/rdf-schema#">
]>

<rdf:RDF xmlns:rdf="&rdf;"
         xmlns:rdfs="&rdfs;"
         xmlns="&daml-o;">

<rdf:Description rdf:about="&daml-o;">
  <versionInfo>$Id: daml-ont.daml,v 1.2 2000/10/11 06:30:02 connolly Exp $</versionInfo>
  <imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
</rdf:Description>

<!-- Terms for building classes from other classes. -->

<Class rdf:ID="&daml-o;Thing">
  <label>Thing</label>
  <comment>The most general class in DAML.</comment>
</Class>

<Class rdf:ID="&daml-o;Nothing">
  <comment>the class with no things in it.</comment>
  <complementOf rdf:resource="&daml-o;Thing"/>
</Class>

<Property rdf:ID="&daml-o;disjointWith">
  <label>disjointWith</label>
  <comment>for disjointWith(X, Y) read: X and Y have no members
	in common.
  </comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;Class"/>
</Property>

<Class rdf:ID="&daml-o;Disjoint">
  <label>Disjoint</label>
  <subClassOf rdf:resource="&daml-o;List"/>
  <comment>for type(L, Disjoint) read: the classes in L are
  pairwise disjoint.

  i.e. if type(L, Disjoint), and C1 in L and C2 in L, then disjointWith(C1, C2).
  </comment>
</Class>

<Property rdf:ID="&daml-o;unionOf">
  <label>unionOf</label>
  <comment>
    for unionOf(X, Y) read: X is the union of the classes in the list Y;
    i.e. if something is in any of the classes in Y, it's in X, and vice versa.
    cf OIL OR</comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;List"/>
</Property>

<Property rdf:ID="&daml-o;disjointUnionOf">
  <label>disjointUnionOf</label>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;List"/>
  <comment>

    for disjointUnionOf(X, Y) read: X is the disjoint union of the classes in
    the list Y: (a) for any c1 and c2 in Y, disjointWith(c1, c2),
    and (b) i.e. if something is in any of the classes in Y, it's
    in X, and vice versa.

    cf OIL disjoint-covered
  </comment>
</Property>

<Property rdf:ID="&daml-o;intersectionOf">
  <comment>
    for intersectionOf(X, Y) read: X is the intersection of the classes in the list Y;
    i.e. if something is in all the classes in Y, then it's in X, and vice versa.
cf OIL AND</comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;List"/>
</Property>

<Property rdf:ID="&daml-o;complementOf">
  <comment>
    for complementOf(X, Y) read: X is the complement of Y; if something is in Y,
    then it's not in X, and vice versa.
cf OIL NOT</comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;Class"/>
</Property>

<!-- List terminology. -->

<Class rdf:ID="&daml-o;List">
  <subClassOf rdf:resource="&rdf;Seq"/>
</Class>

<Property rdf:ID="&daml-o;oneOf">
  <comment>for oneOf(C, L) read everything in C is one of the
     things in L;
     This lets us define classes by enumerating the members.
  </comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;List"/>
</Property>

<Class rdf:ID="&daml-o;Empty">
  <asClass rdf:resource="&daml-o;Nothing"/>
</Class>

<Property rdf:ID="&daml-o;first">
  <domain rdf:resource="&daml-o;List"/>
</Property>

<Property rdf:ID="&daml-o;rest">
  <domain rdf:resource="&daml-o;List"/>
  <range rdf:resource="&daml-o;List"/>
</Property>

<Property rdf:ID="&daml-o;item">
  <comment>for item(L, I) read: I is an item in L; either first(L, I)
    or item(R, I) where rest(L, R).</comment>
  <domain rdf:resource="&daml-o;List"/>
</Property>


<!-- facets of properties. -->

<Property rdf:ID="&daml-o;cardinality">
  <label>cardinality</label>
  <comment>for cardinality(P, N) read: P has cardinality N; i.e.
    everything x in the domain of P has N things y such that P(x, y).
  </comment>
  <domain rdf:resource="&daml-o;Property"/>
</Property>

<Property rdf:ID="&daml-o;maxCardinality">
  <label>maxCardinality</label>
  <comment>for maxCardinality(P, N) read: P has maximum cardinality N; i.e.
    everything x in the domain of P has at most N things y such that P(x, y).
  </comment>
  <domain rdf:resource="&daml-o;Property"/>
</Property>

<Property rdf:ID="&daml-o;minCardinality">
  <comment>for minCardinality(P, N) read: P has minimum cardinality N; i.e.
    everything x in the domain of P has at least N things y such that P(x, y).
  </comment>
  <domain rdf:resource="&daml-o;Property"/>
</Property>

<Property rdf:ID="&daml-o;inverseOf">
  <comment>for inverseOf(R, S) read: R is the inverse of S; i.e.
     if R(x, y) then S(y, x) and vice versa.</comment>
  <domain rdf:resource="&daml-o;Property"/>
  <range rdf:resource="&daml-o;Property"/>
</Property>

<Class rdf:ID="&daml-o;TransitiveProperty"/>

<Class rdf:ID="&daml-o;UniqueProperty">
  <label>UniqueProperty</label>
  <comment>compare with maxCardinality=1; e.g. integer successor:
	if P is a UniqueProperty, then
	if P(x, y) and P(x, z) then y=z.
	aka functional.
  </comment>
  <subClassOf rdf:resource="&daml-o;Property"/>
</Class>

<Class rdf:ID="&daml-o;UnambiguousProperty">
  <label xml:lang="en">UnambiguousProperty</label>
  <comment>if P is an UnambiguousProperty, then
	if P(x, y) and P(z, y) then x=z.
	aka injective.
	e.g. if nameOfMonth(m, "Feb")
	and nameOfMonth(n, "Feb") then m and n are the same month.
  </comment>
  <subClassOf rdf:resource="&daml-o;Property"/>
</Class>


<!-- Terms for restricting properties of things in classes. -->

<Class rdf:ID="&daml-o;Restriction"/>

<Property rdf:ID="&daml-o;restrictedBy">
  <label>restrictedBy</label>
  <comment>for restrictedBy(C, R), read: C is restricted by R; i.e. the
	restriction R applies to c;

        if onProperty(R, P) and toValue(R, V)
        then for every i in C, we have P(i, V).

        if onProperty(R, P) and toClass(R, C2)
        then for every i in C and for all j, if P(i, j) then type(j, C2).
  </comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;Restriction"/>
</Property>

<Property rdf:ID="&daml-o;onProperty">
  <comment>for onProperty(R, P), read:
   R is a restriction/qualification on P.</comment>
  <domain rdf:resource="&daml-o;Restriction"/>
  <domain rdf:resource="&daml-o;Qualification"/>
  <range rdf:resource="&daml-o;Property"/>
</Property>

<Property rdf:ID="&daml-o;toValue">
  <comment>for toValue(R, V), read: R is a restriction to V.</comment>
  <domain rdf:resource="&daml-o;Restriction"/>
  <range rdf:resource="&daml-o;Class"/>
</Property>

<Property rdf:ID="&daml-o;toClass">
  <comment>for toClass(R, C), read: R is a restriction to C.</comment>
  <domain rdf:resource="&daml-o;Restriction"/>
  <range rdf:resource="&daml-o;Class"/>
</Property>

<Class rdf:ID="&daml-o;Qualification"/>

<Property rdf:ID="&daml-o;qualifiedBy">
  <label>qualifiedBy</label>
  <comment>for qualifiedBy(C, Q), read: C is qualified by Q; i.e. the
	qualification Q applies to C;

        if onProperty(Q, P) and hasValue(Q, C2)
        then for every i in C, there is some V
	so that type(V, C2) and P(i, V).
  </comment>
  <domain rdf:resource="&daml-o;Class"/>
  <range rdf:resource="&daml-o;Qualification"/>
</Property>

<Property rdf:ID="&daml-o;hasValue">
  <label>hasValue</label>
  <comment>for hasValue(Q, C), read: Q is a hasValue
   qualification to C.</comment>
  <domain rdf:resource="&daml-o;Qualification"/>
  <range rdf:resource="&daml-o;Class"/>
</Property>


<!-- A class for ontologies themselves... -->

<Class rdf:ID="&daml-o;Ontology">
  <label>Ontology</label>
  <comment>An Ontology is a document that describes
	a vocabulary of terms for communication between
	(human and) automated agents.
  </comment>
</Class>

<Property rdf:ID="&daml-o;versionInfo">
  <label>versionInfo</label>
  <comment>generally, a string giving information about this
	version; e.g. RCS/CVS keywords
  </comment>
</Property>

<!-- Importing, i.e. assertion by reference -->

<Property rdf:ID="&daml-o;imports">
  <label>imports</label>
  <comment>for imports(X, Y) read: X imports Y;
	i.e. X asserts the* contents of Y by reference;
	i.e. if imports(X, Y) and you believe X and Y says something,
	then you should believe it.

	Note: "the contents" is, in the general case,
	an il-formed definite description. Different
	interactions with a resource may expose contents
	that vary with time, data format, preferred language,
	requestor credentials, etc. So for "the contents",
	read "any contents".
  </comment>
</Property>

<!-- Renaming -->

<Property rdf:ID="&daml-o;equivalentTo"> <!-- equals? equiv? renames? -->
  <comment>for equivalentTo(X, Y), read X is an equivalent term to Y.
  </comment>

	<!--@@RDF specs prohibits cycles, but I don't buy it. -->
  <subPropertyOf rdf:resource="&daml-o;subPropertyOf"/>
  <subPropertyOf rdf:resource="&daml-o;subClassOf"/>
</Property>

<!-- Importing terms from RDF/RDFS -->

<!-- first, assert the contents of the RDF schema by reference -->
<Ontology rdf:about="&daml-o;">
  <imports rdf:resource="http://www.w3.org/2000/01/rdf-schema"/>
</Ontology>


<Property rdf:ID="&daml-o;subPropertyOf">
  <equivalentTo  rdf:resource="&rdfs;subPropertyOf"/>
  <subPropertyOf rdf:resource="&rdfs;subPropertyOf"/>
  <!-- the subPropertyOf is for the benefit of agents that know RDFS
       but don't know DAML. -->
</Property>

<Class rdf:ID="&daml-o;Class">
  <equivalentTo rdf:resource="&rdfs;Class"/>
</Class>

<Class rdf:ID="&daml-o;Literal">
  <equivalentTo rdf:resource="&rdfs;Literal"/>
</Class>

<Class rdf:ID="&daml-o;Property">
  <equivalentTo rdf:resource="&rdf;Property"/>
</Class>

<Property rdf:ID="&daml-o;type">
  <equivalentTo rdf:resource="&rdf;type"/>
</Property>

<Property rdf:ID="&daml-o;value">
  <equivalentTo rdf:resource="&rdf;value"/>
</Property>

<Property rdf:ID="&daml-o;subClassOf">
  <equivalentTo rdf:resource="&rdfs;subClassOf"/>
</Property>

<Property rdf:ID="&daml-o;domain">
  <equivalentTo rdf:resource="&rdfs;domain"/>
</Property>

<Property rdf:ID="&daml-o;range">
  <equivalentTo rdf:resource="&rdfs;range"/>
</Property>

<Property rdf:ID="&daml-o;label">
  <equivalentTo rdf:resource="&rdfs;label"/>
</Property>

<Property rdf:ID="&daml-o;comment">
  <equivalentTo rdf:resource="&rdfs;comment"/>
</Property>

<Property rdf:ID="&daml-o;seeAlso">
  <equivalentTo rdf:resource="&rdfs;seeAlso"/>
</Property>

<Property rdf:ID="&daml-o;isDefinedBy">
  <equivalentTo rdf:resource="&rdfs;isDefinedBy"/>
  <subPropertyOf rdf:resource="&daml-o;seeAlso"/>
</Property>

<Property rdf:ID="&daml-o;default">
  <label>default</label>
  <comment>default(X, Y) suggests that Y be considered a/the default
	value for the X property. This can be considered
	documentation (ala label, comment) but we don't specify
	any logical impact.
  </comment>
</Property>

<!-- from RDF, left out:
	Bag, Alt: why bother? note that we can't import
		the syntax of these into the DAML namespace if we expect
		RDF 1.0 parsers to grok.
	predicate, subject, object, Statement: DAML audience doesn't need quoting.
-->

<!-- from RDFS, left out
	Container: the motivation for this, to somehow denote that other
		element names can be used with the <li> syntax, is busted.
	ContainerMembershipProperty: without the <li> syntax, not much use for this.
	ConstraintResource, ConstraintProperty: I don't grok these.
 -->


</rdf:RDF>

s/xmlns//;
t del

s/resource=/rdf:resource=/;
s/ID="/rdf:ID="\&daml-o;/;
s/about=""/rdf:about="\&daml-o;"/;
s/="#/="\&daml-o;/;
s/http:\/\/www.w3.org\/2000\/01\/rdf-schema#/\&rdfs;/;
s/http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#/\&rdf;/;
b

: del
d
Received on Tuesday, 24 October 2000 17:34:21 GMT

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