Copyright ©1998,1999,2000 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
This specification describes how to use RDF to describe RDF vocabularies. The specification also defines a basic vocabulary for this purpose, as well as an extensibility mechanism to anticipate future additions to RDF.
This document is a Candidate Recommendation of the World Wide Web Consortium. Review comments on this specification should be sent by June 15, 2000 to <www-rdf-comments@w3.org>. The archive of public comments is available at http://lists.w3.org/Archives/Public/www-rdf-comments. Private comments that you wish to be visible only to the editors, working group chair, and W3C staff may be sent to <w3c-rdf-review@w3.org>.
This specification is a revision of the Proposed Recommendation of March 03 1999, incorporating editorial suggestions received in review comments. A separate document provides an overview of the main changes since the last publication of this work. With the publication of this document, the RDF Schema specification enters W3C Candidate Recommendation phase. W3C encourages active implementation to test this specification during the Candidate Recommendation review period; reports of implementation experience sent to the review address are especially desired.
The Resource Description Framework is part of the W3C Metadata Activity. The goal of this activity, and of RDF specifically, is to produce a language for the exchange of machine-understandable descriptions of resources on the Web. A separate specification describes the data model and syntax for the interchange of metadata using RDF.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. Identified Errata in this document and the latest status of this document series is maintained at the W3C. Refer to Appendix B, About W3C Documents, for a description of the W3C Technical Report publishing policy.
It is inappropriate to use W3C Candidate Recommendations as reference material or to cite them as other than "work in progress". This is work in progress and does not imply endorsement by, or the consensus of W3C. Advancement of a document to Candidate Recommendation is an explicit call for implementation and technical feedback; it is appropriate to build implementations based on this specification for the purposes of testing the specification and becoming familiar with it. A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR.
The Resource Description Framework (RDF) is a foundation for processing metadata; it provides interoperability between applications that exchange machine-understandable information on the Web. RDF uses XML to exchange descriptions of Web resources but the resources being described can be of any type, including XML and non-XML resources. RDF emphasizes facilities to enable automated processing of Web resources. RDF can be used in a variety of application areas, for example: in resource discovery to provide better search engine capabilities, in cataloging for describing the content and content relationships available at a particular Web site, page, or digital library, by intelligent software agents to facilitate knowledge sharing and exchange, in content rating, in describing collections of pages that represent a single logical "document", for describing intellectual property rights of Web pages, and for expressing the privacy preferences of a user as well as the privacy policies of a Web site. RDF with digital signatures will be key to building the "Web of Trust" for electronic commerce, collaboration, and other applications.
Descriptions used by these applications can be modeled as relationships among Web resources. The RDF data model, as specified in [RDFMS], defines a simple model for describing interrelationships among resources in terms of named properties and values. RDF properties may be thought of as attributes of resources and in this sense correspond to traditional attribute-value pairs. RDF properties also represent relationships between resources. As such, the RDF data model can therefore resemble an entity-relationship diagram. The RDF data model, however, provides no mechanisms for declaring these properties, nor does it provide any mechanisms for defining the relationships between these properties and other resources. That is the role of RDF Schema.
Resource description communities require the ability to say certain things about certain kinds of resources. For describing bibliographic resources, for example, descriptive attributes including "author", "title", and "subject" are common. For digital certification, attributes such as "checksum" and "authorization" are often required. The declaration of these properties (attributes) and their corresponding semantics are defined in the context of RDF as an RDF schema. A schema defines not only the properties of the resource (e.g., title, author, subject, size, color, etc.) but may also define the kinds of resources being described (books, Web pages, people, companies, etc.).
This document does not specify a vocabulary of descriptive elements
such as "author". Instead, it specifies the mechanisms
needed to define such elements, to define the classes of resources they
may be used with, to restrict possible combinations of classes and relationships,
and to detect violations of those restrictions. Thus, this document
defines a schema specification language. More succinctly, the
RDF Schema mechanism provides a basic type system for use in RDF
models. It defines resources and properties such as
rdfs:Class and rdfs:subClassOf that are used in
specifying application-specific schemas.
The typing system is specified in terms of the basic RDF data model - as resources and properties. Thus, the resources constituting this typing system become part of the RDF model of any description that uses them. The schema specification language is a declarative representation language influenced by ideas from knowledge representation (e.g., semantic nets, frames, predicate logic) as well as database schema specification languages (e.g. NIAM) and graph data models. The RDF schema specification language is less expressive, but much simpler to implement, than full predicate calculus languages such as CycL [CycL] and KIF [KIF].
RDF and the RDF Schema language were also based on metadata research in the Digital Library community. In particular, RDF adopts a modular approach to metadata that can be considered an implementation of the Warwick Framework [WF]. RDF represents an evolution of the Warwick Framework model in that the Warwick Framework allowed each metadata vocabulary to be represented in a different syntax. In RDF, all vocabularies are expressed within a single well defined model. This allows for a finer grained mixing of machine-processable vocabularies, and addresses the need [EXTWEB] to create metadata in which statements can draw upon multiple vocabularies that are managed in a decentralized fashion by independent communities of expertise.
RDF Schemas might be contrasted with XML Document Type Definitions (DTDs) [XML] and XML Schemas [XMLSCHEMA]. Unlike an XML DTD or Schema, which gives specific constraints on the structure of an XML document, an RDF Schema provides information about the interpretation of the statements given in an RDF data model. While an XML Schema can be used to validate the syntax of an RDF/XML expression, a syntactic schema alone is not sufficient for RDF purposes. RDF Schemas may also specify constraints that should be followed by these data models. Future work on RDF Schema and XML Schema might enable the simple combination of syntactic and semantic rules from both [SCHEMA-ARCH].
This RDF Schema specification has intentionally left unspecified a set of primitive datatypes. As RDF uses XML for its interchange encoding, the work on data typing in XML [XMLDATATYPES] itself should be the foundation for such a capability.
The RDF Schema specification is not aimed at theoretical issues, but at solving a small number of immediate problems. Its creators expect that other problems (some of which are illustrated in the examples below) will share similar characteristics and that they also may be able to use the basic classes described in this specification.
The RDF Schema specification was directly influenced by consideration of the following problems:
The RDF Model and Syntax is adequate to represent PICS labels [PICS], however it does not provide a general-purpose mapping from PICS rating systems into an RDF representation. One such mapping is described in a separate document.
One obvious application for RDF is in the description of Web pages. This is one of the basic goals of the Dublin Core [DC] Metadata Initiative. The Dublin Core Element Set is a set of 15 elements believed to be broadly applicable to describing Web resources to enable their discovery. The Dublin Core has been a major influence on the development of RDF. An important consideration in the development of the Dublin Core was to not only allow simple descriptions, but also to provide the ability to qualify descriptions in order to provide both domain specific elaboration and descriptive precision.
The RDF Schema Specification provides a machine-understandable system for defining schemas for descriptive vocabularies like the Dublin Core. It allows designers to specify classes of resource types and properties to convey descriptions of those classes, relationships between those properties and classes, and constraints on the allowed combinations of classes, properties, and values.
A sitemap is a hierarchical description of a Web site. A subject taxonomy is a classification system that might be used by content creators or trusted third parties to organize or classify Web resources. The RDF Schema specification provides a mechanism for defining the vocabularies needed for such applications.
Thesauri and library classification schemes are well known examples of hierarchical systems for representing subject taxonomies in terms of the relationships between named concepts. The RDF Schema specification provides sufficient resources for creating RDF models that represent the logical structure of thesauri (and other library classification systems).
The W3C Platform for Privacy Preferences Project (P3P) has specified a grammar for constructing statements about a site's data collection practices and personal preferences as exercised over those practices, as well as a syntax for exchanging structured data.
Although personal data collection practices have been described in P3P using an application-specific XML tagset, there are benefits to using a general metadata model for this data. The structure of P3P policies can be interpreted as an RDF model. Using a metadata schema to describe the semantics of privacy practice descriptions will permit privacy practice data to be used along with other metadata in a query during resource discovery, and will permit a generic software agent to act on privacy metadata using the same techniques as used for other descriptive metadata. Extensions to P3P that describe the specific data elements collected by a site could use RDF Schema to further specify how those data elements are used.
An RDF Schema is expressed by the data model described in the RDF Model and Syntax [RDFMS] specification. The schema description language is simply a set of resources and properties defined by the RDF Schema Specification and implicitly part of every RDF model using the RDF schema machinery.
This document specifies the RDF Schema mechanism as a set of RDF resources (including classes and properties), and constraints on their relationships. The abstract RDF Schema core vocabulary can be used to make RDF statements defining and describing application-specific vocabularies such as the Dublin Core Element Set.
The RDF Schema defined in this specification is a collection of RDF resources
that can be used to describe properties of other RDF resources (including properties)
which define application-specific RDF vocabularies.
The core schema vocabulary is defined in a namespace informally called
'rdfs' here, and identified by
the URI reference http://www.w3.org/2000/01/rdf-schema#.
This specification also uses the prefix 'rdf' to refer to
the core RDF namespace http://www.w3.org/1999/02/22-rdf-syntax-ns#.
As described in the RDF Model and Syntax specification
[RDFMS], resources may be instances of
one or more classes; this is indicated with the rdf:type
property. Classes themselves are often organized in a hierarchical
fashion, for example a class Dog might be considered a subclass of
Mammal which is a subclass of Animal, meaning that any
resource which is of rdf:type Dog is also considered to be of
rdf:type Animal. This specification describes a
property, rdfs:subClassOf, to denote such relationships
between classes.
The RDF Schema type system is similar to the type systems of
object-oriented programming languages such as Java.
However, RDF differs from many such systems in that instead of defining
a class in terms of the properties its instances may have, an RDF schema
will define properties in terms of the classes of resource to which
they apply. This is the role of the rdfs:domain and
rdfs:range constraints described in
Section 3. For example,
we could define the author property to
have a domain of Book and a range of Literal,
whereas a classical OO system might typically define a class
Book with an attribute called
author of type Literal. One benefit of the RDF
property-centric approach is that it is very easy for anyone to say
anything they want about existing resources, which is one of the
architectural principles of the Web [BERNERS-LEE98].
This specification anticipates the development of a set of classes corresponding to a set of
datatypes. This specification does not define any specific datatypes, but
does note that datatypes may be used as the value of the
rdfs:range property.
rdf:type property of that resource whose value is the resource defining the
containing class. (These properties are shown as arcs in the directed labelled
graph representation in figure 2). The RDF resources depicted in figure 1
are described either in the remainder of this specification, or in the RDF
Model and Syntax specification.
Figure 1: Classes and Resources as Sets and Elements
Figure 2 shows the same information about the class hierarchy
as in figure 1, but does so using a "nodes and arcs" graph representation of
the RDF data model.
If one class is a subset of another, then there is an rdfs:subClassOf
arc from the node
representing the first class to the node representing the second. Similarly,
if a resource is an instance of a class, then there is an rdf:type
arc from the resource to the node representing the class. Not all such arcs are shown.
We only show the arc to the most tightly encompassing class, and rely on the transitivity
of the rdfs:subClassOf relation to provide the rest.
Figure 2: Class Hierarchy for the RDF Schema
The following resources are the core classes that are defined as part of the RDF Schema vocabulary. Every RDF model that draws upon the RDF Schema namespace (implicitly) includes these.
All things being described by RDF expressions are called resources, and are
considered to be instances of the class rdfs:Resource.
The RDF class rdfs:Resource
represents the set called 'Resources' in the formal model for RDF presented in section 5 of
the Model and Syntax specification [RDFMS].
rdf:Property represents the subset of RDF resources that are properties,
i.e., all the elements of the set introduced as 'Properties' in section 5 of the Model
and Syntax specification [RDFMS].
This corresponds to the generic concept of a Type or
Category, similar to the notion of a Class in object-oriented
programming languages such as Java.
When a schema defines a new class, the resource representing that class must
have an rdf:type property whose value is the resource rdfs:Class.
RDF classes can be defined to represent almost anything, such as Web pages, people, document types,
databases or abstract concepts.
Every RDF model which uses the schema mechanism
also (implicitly) includes the following core properties.
These are instances of the rdf:Property class and provide
a mechanism for expressing relationships between classes and their instances
or superclasses.
This indicates that a resource is a member of a class, and thus has all
the characteristics that are to be expected of a member of that class.
When a resource has an rdf:type property whose value is
some specific class, we say
that the resource is an instance of the specified class. The value of an
rdf:type property for some resource is
another resource which must be an instance of rdfs:Class.
The resource known as rdfs:Class is itself a resource of rdf:type
rdfs:Class. Individual classes (for example, 'Dog') will always have an
rdf:type property whose value is rdfs:Class (or some subclass
of rdfs:Class, as described in section 2.3.2). A resource may be an instance
of more than one class.
This property specifies a subset/superset relation between classes.
The rdfs:subClassOf property is transitive.
If class A is a subclass of some broader class B, and B is a subclass of
C, then A is also implicitly a subclass of C. Consequently, resources
that are instances of class A will also be instances of C, since A is a
sub-set of both B and C. Only instances of rdfs:Class can have the
rdfs:subClassOf property and the property value is always of
rdf:type rdfs:Class. A class may be a
subclass of more than one class.
A class can never be declared to be a subclass of itself, nor of any of its own subclasses. Note that this constraint is not expressible using the RDF Schema constraint facilities provided below, and so does not appear in the RDF version of this specification given in Appendix A.
This is a very simple example that expresses the following class
hierarchy. We first define a class MotorVehicle. We then
define three subclasses of MotorVehicle, namely PassengerVehicle,
Truck and
Van. We then define a class Minivan which is a subclass of both
Van and PassengerVehicle.
The RDF/XML shown here uses the basic RDF syntax defined in section 2.2.1 of the Model and Syntax specification [RDFMS]. abbreviation mechanism provided by the RDF serialization syntax.
|
The property rdfs:subPropertyOf is an instance of
rdf:Property that is used to specify that one
property is a specialization of another.
A property may be a specialization of zero, one or more properties.
If some property P2 is a subPropertyOf another more
general property P1, and if a resource A has a P2 property with a value B,
this implies that the resource A also has a P1 property with
value B.
A property can never be declared to be a subproperty of itself, nor of any of its own subproperties. Note that this constraint is not expressible using the RDF Schema constraint facilities provided below, and so does not appear in the RDF version of this specification given in Appendix A.
If the property biologicalFather is a
subproperty of the broader property biologicalParent, and if
Fred is the
biologicalFather of John, then it is implied that Fred is also the
biologicalParent of John.
|
The property rdfs:seeAlso
specifies a resource that might provide additional information about the
subject resource. This
property may be specialized using rdfs:subPropertyOf to more precisely
indicate the nature of the information the object resource has about the
subject resource. The object and the subject resources are constrained only to be instances of the class
rdfs:Resource.
The property rdfs:isDefinedBy is a subproperty of
rdfs:seeAlso, and indicates the resource
defining the subject resource. As with rdf:seeAlso, this
property can be applied to any instance of rdfs:Resource and may have
as its value any rdfs:Resource.
The most common anticipated usage is to identify an RDF schema, given a name for one of the properties or classes defined by that schema. Although XML namespace declarations will typically provide the URI where RDF vocabulary resources are defined, there are cases where additional information is required.
For example, constructs such as
<rdfs:subPropertyOf
rdf:resource="http://purl.org/dc/elements/1.0/Creator"/>
do not
indicate the URI of the schema that includes the vocabulary item
Creator (i.e., http://purl.org/dc/elements/1.0/).
In such cases, the rdfs:isDefinedBy property can be used to explicitly
represent that
information. This approach will also work when the URIs of the namespace and its
components have no obvious relationship, as would be the case if they
were identified using schemes such as GUIDs or MD-5 hashes.
This specification introduces an RDF vocabulary for making statements about constraints on the use of properties and classes in RDF data. For example, an RDF schema might describe limitations on the types of values that are valid for some property, or on the classes to which it makes sense to ascribe such properties.
RDF Schema provides a mechanism for describing such constraints, but does
not say whether or how an application must process the constraint information.
For example, while an RDF schema can assert that
an author property is used to indicate resources that are members of
the class Person, it does not say whether or how an application should act in processing
that class information. We expect that different applications will use these
constraints in different ways - e.g., a validator will look for errors,
an interactive editor might suggest legal values, and a reasoning
application might infer the class and then announce any inconsistencies.
RDF schemas can express constraints that relate vocabulary items from
multiple independently developed schemas. Since URI references are used to
identify classes and properties, it is possible to create new properties
whose domain or range constraints
reference classes defined in another namespace.
The following constraints are specified in RDF Schema 1.0: rdfs:domain
and rdfs:range constraints on property usage,
the rule that rdfs:subPropertyOf and rdfs:subClassOf properties
should not form loops, plus any further constraints defined using the
rdfs:ConstraintResource extensibility mechanism.
Different applications may exhibit different behaviors when dealing with
RDF constraints.
Some examples of constraints include:
author property might express that the
value of an author property must be a resource of class Person.
author property could only originate from a
resource that was an instance of class Book.
This specification does not attempt to enumerate every possible form of constraint applicable to RDF vocabulary description. Instead, some basic constraint mechanisms are defined here, accompanied by an extension facility to allow for the subsequent additions of new types of constraint.
Although the RDF data model does not allow for explicit properties (such
as an rdf:type property) to be ascribed to Literals (atomic values),
we nevertheless consider these entities to be members of classes (e.g.,
the string "John Smith" is considered to be a member of the class
rdfs:Literal.)
Note: We expect future work in RDF and XML data-typing to provide clarifications in this area.
This resource defines a subclass of rdfs:Resource whose
instances are RDF schema constructs involved in the expression of
constraints. The purpose of this class is to provide a mechanism
that allows RDF processors to assess their ability to use the constraint
information associated with an RDF model. Since this specification does not provide a
mechanism for the dynamic discovery of new forms of constraint, an RDF
Schema 1.0 processor encountering previously unknown instances of
rdfs:ConstraintResource can be sure that it is
unqualified to determine the meaning of those constraints.
This resource defines a subclass of rdf:Property, all of whose instances
are properties used to specify constraints. This class is a subclass
of rdfs:ConstraintResource and corresponds to the subset of
that class representing properties. Both rdfs:domain
and rdfs:range are instances of
rdfs:ConstraintProperty.
An instance of ConstraintProperty that is used to
indicate the class(es) that the values of a property must be members of.
The value of a range property is always a
Class. Range constraints are only applied to properties.
A property can have at most one range property. It is possible for it to have no range, in which case the class of the property value is unconstrained.
The rdfs:domain of rdfs:range is the class
rdf:Property.
This indicates that the range property applies to resources that are themselves properties.
The rdfs:range of rdfs:range is the class
rdfs:Class.
This indicates that any resource that is the value of a range property will be a class.
Although it is not permitted to express two or morerangeconstraints on a property, a similar outcome can be achieved by defining a common superclass for any classes that represent appropriate values for some property. For example, to express the constraint that a propertyxyz:drivesMotorVehiclecan have values which are Vans, Trucks or PassengerVehicles, we assert thatxyz:drivesMotorVehiclehas ardfs:rangeofMotorVehicle. IfVan,TruckandPassengerVehicleare known to be subcl