The Resource Description Framework (RDF) is a framework for
representing information in the Web.
RDF Concepts and Abstract Syntax defines an abstract syntax on which RDF is based, and which serves to link its concrete syntax to its formal semantics. It also includes discussion of design goals, key concepts, datatyping, character normalization and handling of URI references.
This document is an unofficial editors' working copy, which is being used to make proposed changes available for discussion by the RDFcore working group. It has no official status, and has not been approved for publication by the working group. A version of this document that is available for public discussion of issues can be found in the RDFcore shadow documents area, http://www.w3.org/2001/sw/RDFCore/TR/. Versions of this document that may be available at any other location may be subject to change at any time, and should not be used as a basis for public discussion.
[[[Last-call document status commented out below]]]
The Resource Description Framework (RDF) is a framework for
representing information in the Web.
This document defines an abstract syntax on which RDF is based, and which serves to link its concrete syntax to its formal semantics. It also includes discussion of design goals, key concepts, datatyping, character normalization and handling of URI references.
Normative documentation of the RDF core falls into the following
areas:
Within this document, normative sections are explicitly labelled as
such. Explicit notes are informative.
The framework is designed so that vocabularies can be layered on
top of a core. The RDF core and RDF vocabulary definition (RDF schema)
languages [RDF-VOCABULARY] are
the first such vocabularies. Others (cf. OWL [OWL] and the applications in the primer [RDF-PRIMER]) are in development.
In section 2, the background
rationale and design goals are introduced. Key concepts follow in section 3.
RDF's abstract syntax is a graph, which can be serialized using
XML (but which is quite distinct from XML's tree-based infoset [XML-INFOSET]). The abstract syntax
captures the fundamental structure of RDF, independently of any
concrete syntax used for serialization. The formal semantics of RDF
are defined in terms of the abstract syntax. XML content of
literals is described in section 5,
and the abstract syntax is defined in section
6 of this document.
Section 7 discusses the role of
fragment identifiers in URI references used with RDF.
RDF has an abstract syntax that reflects a simple graph-based
data model, and formal semantics with a rigorously defined notion
of entailment providing a basis for well founded deductions in RDF
data.
The development of RDF has been motivated by the following uses,
among others:
- Web metadata: providing information about Web resources and
the systems that use them (e.g. content rating, capability
descriptions, privacy preferences, etc.)
- Applications that require open rather than constrained
information models (e.g. scheduling activities, describing
organizational processes, annotation of Web resources, etc.)
- To do for machine processable information (application data)
what the World Wide Web has done for hypertext: to allow data to
be processed outside the particular environment in which it was
created, in a fashion that can work at Internet scale.
- Interworking among applications: combining data from several
applications to arrive at new information.
- Automated processing of Web information by software agents:
the Web is moving from having just human-readable information to
being a world-wide network of cooperating processes. RDF provides
a world-wide lingua franca for these processes.
RDF is designed to represent information in a minimally
constraining, flexible way. It can be used in isolated
applications, where individually designed formats might be more
direct and easily understood, but RDF's generality offers greater
value from sharing. The value of information thus increases as it
becomes accessible to more applications across the entire Internet.
The design of RDF is intended to meet the following goals:
- having a simple data model
- having formal semantics and provable inference
- using an extensible URI-based vocabulary
- using an XML-based syntax
- supporting use of XML schema datatypes
- allowing anyone to make statements about any resource
RDF has a simple data model that is easy for applications to
process and manipulate. The data model is independent of any
specific serialization syntax.
Note: the term "model" used here in "data model" has a completely different sense to its use in the term "model theory". See the RDF Semantics specification [RDF-SEMANTICS] for more
information about "model theory" as used in the literature of
mathematics and logic.
RDF has a formal semantics which provides a dependable basis for
reasoning about the meaning of an RDF expression. In particular, it
supports rigorously defined notions of entailment which provide a
basis for defining reliable rules of inference in RDF data.
The vocabulary is fully extensible, being based on URIs with
optional fragment identifiers (URI references, or URIrefs).
URI references are used for naming all kinds of things in RDF.
The other kind of value that appears in RDF data is a literal.
RDF has a recommended XML serialization form [RDF-SYNTAX], which can be used to encode
the data model for exchange of information among applications.
RDF can use values represented according to XML schema datatypes
[XML-SCHEMA2], thus assisting the
exchange of information between RDF and other XML applications.
To facilitate operation at Internet scale, RDF is an open-world framework that allows anyone to make statements about any resource.
In general, it is not assumed that complete information about any resource is available. RDF does not prevent anyone from making assertions that are nonsensical or inconsistent with other statements, or the world as people see it. Designers of applications that use RDF should be aware of this and may design their applications to tolerate incomplete or inconsistent sources of information.
RDF uses the following key concepts:
- Graph data model
- URI-based vocabulary
- Datatypes
- Literals
- XML serialization syntax
- Expression of simple facts
- Entailment
The underlying structure of any expression in RDF is a collection of triples, each consisting of a subject, a predicate and an object. A set of such triples is called an RDF graph (defined more formally in section 6). This can be illustrated by a node and directed-arc diagram, in which each triple is represented as a node-arc-node link (hence the term "graph").
Each triple represents a statement of a relationship between the things denoted by the nodes that it links. Each triple has three parts:
- a subject,
- an object, and
- a predicate (also called a property) that denotes a relationship.
The direction of the arc is significant: it always points toward the object.
The nodes of an RDF graph are its subjects and objects.
The assertion of an RDF triple says that some relationship, indicated by the predicate, holds between the things denoted by subject and object of the triple. The assertion of an RDF graph amounts to asserting all the triples in it, so the meaning of an RDF graph is the conjunction (logical AND) of the statements corresponding to all the triples it contains. A formal account of the meaning of RDF graphs is given in [RDF-SEMANTICS].
A node may be a URI with optional fragment identifier (URI reference, or URIref), a literal, or blank (having no separate form of identification). Properties are URI references. (See [URI], section 4, for a description of URI
reference forms, noting that relative URIs are not used in an RDF
graph. See also section 6.4.)
A URI reference or literal used as a node identifies what that node represents. A URI reference used as a predicate identifies the relationship between the nodes it connects. A predicate URI reference may also be a node in the graph.
A blank node is a node that is not a URI reference or a literal. In the RDF abstract syntax, a blank node is just a unique node that can be used in one or more RDF statements, and has no globally distinguishing identity.
A convention used by some linear representations of an RDF graph to allow several statements to reference the same unidentified resource is to use a blank
node identifier, which is a local identifier that can be distinguished from all URIs and literals. When graphs are merged, their blank nodes must be kept distinct if meaning is to be preserved; this may call for re-allocation of blank node identifiers. Note that such blank node identifiers are not part of the RDF abstract syntax, and the representation of triples containing blank nodes is entirely dependent on the particular concrete syntax used.
Datatypes are used by RDF in the representation of values such
as integers, floating point numbers and dates.
RDF uses the datatype abstraction defined by XML Schema Part 2:
Datatypes [XML-SCHEMA2], and may be used
with any datatype definition that conforms to this abstraction, even if
not actually defined in terms of XML Schema.
A datatype
mapping is a set of pairs whose first element belongs to
the lexical
space of the datatype, and the second element belongs to
the value space
of the datatype:
- Each member of the lexical space is paired with
(maps to) exactly one member of the value space.
- Each member of the value space may be paired with
any number (including zero) of members of the lexical
space (lexical representations for that value).
With one exception, the datatypes used in RDF have a lexical
space consisting of a set of strings. The exception is rdf:XMLLiteral, whose
lexical space also includes pairs of strings and language
identifiers. The value obtained through its datatype mapping may
depend on the language identifier.
For example, the datatype mapping for the XML Schema datatype xsd:boolean,
where each member of the value space (represented here as 'T' and
'F') has two lexical representations, is as follows:
| Value Space |
{T, F} |
| Lexical Space |
{"0", "1", "true", "false"} |
| Datatype Mapping |
{<"true", T>, <"1", T>, <"0", F>,
<"false", F>} |
RDF predefines just one datatype rdf:XMLLiteral, used for embedding XML in RDF
(see section 5).
There is no built-in concept of numbers or dates or other common
values. Rather, RDF defers to datatypes that are defined
separately, and identified with URI references.The predefined XML
Schema datatypes [XML-SCHEMA2] are
expected to be widely used for this purpose.
Certain XML Schema built-in datatypes are not suitable for use
within RDF. For example, the QName
datatype requires a namespace declaration to be in scope during the
mapping, and is not recommended for use in RDF.
RDF provides no mechanism for defining new datatypes. XML Schema
Datatypes [XML-SCHEMA2] provides an
extensibility framework suitable for defining new datatypes for use
in RDF.
Literals are used to identify values such as numbers and dates
by means of a lexical representation. Anything represented by a
literal could also be represented by a URI, but it is often more
convenient or intuitive to use literals.
A literal may be the object of an RDF statement, but not the
subject or the arc.
Literals may be plain or typed :
- A plain literal is a string
combined with an optional language identifier. This should be
used for plain text in a natural language. As recommended in the
RDF formal semantics [RDF-SEMANTICS],
these plain literals are self-denoting.
- A typed literal is a string, a
datatype URI and an optional language identifier. It denotes the
member of the identified datatype's value space obtained by
applying the datatype mapping to the literal string.
Continuing the example from section
3.3, the typed literals which can be defined using the XML
Schema datatype xsd:boolean are:
| Typed Literal |
Datatype Mapping |
Value |
| <xsd:boolean, "true"> |
<"true", T> |
T |
| <xsd:boolean, "1"> |
<"1", T> |
T |
| <xsd:boolean, "false"> |
<"false", F> |
F |
| <xsd:boolean, "0"> |
<"0", F> |
F |
RDF provides a framework to make information about resources readily accessible for automated processing. It is domain neutral, so a broad range of information can be expressed, and diverse kinds of information may be combined in a single RDF graph.
A simple fact expressed in RDF may indicate a relationship between two resources, in the form of an RDF triple in which the predicate names the relationship, and the subject and object denote the two resources. A familiar representation of such a fact might be as a row in a table of a relational database, where the table has two columns corresponding to the subject and the object of the RDF triple. The name of the table corresponds to the predicate of the RDF triple. Another representation may be as a two place predicate in first order logic.
Other simple facts may involve assertion of a relationship between three or more resources (e.g. corresponding to relational database table with three or more columns). Multiple RDF statements can be used together to express this kind of information, as discussed in section 2.3 of the [RDF-PRIMER].
Through its use of extensible URI-based vocabularies, RDF provides for expression of facts about arbitrary subjects; i.e. assertions of named properties about identified things. A URI can be constructed for any thing that can be named, so RDF statements can express facts about any such things.
The ideas on meaning and inference in RDF are underpinned by the
formal concept of entailment,
as discussed in the RDF semantics document [RDF-SEMANTICS]. In brief, an RDF
expression A is said to entail another RDF expression B
if every possible arrangement of things in the world that makes A true
also makes B true. On this basis, if the truth of A is presumed or
demonstrated then the truth of B can be inferred .
RDF uses URI references to identify resources and properties. Certain URI references are reserved for use by RDF, and should not be used in ways not supported by the RDF specifications. Specifically, URI references with the following leading substrings are reserved for definition by the RDF specifications:
- http://www.w3.org/1999/02/22-rdf-syntax-ns#
(conventionally associated with namespace prefix rdf:)
- http://www.w3.org/2000/01/rdf-schema#
(conventionally associated with namespace prefix rdfs:)
Used with the RDF/XML serialization, these URI prefix strings correspond to XML namespace names [XML-NS]
associated with the RDF core vocabulary terms.
Note: these namespace names are the same as those used in earlier RDF documents [RDF-MS] [RDF-SCHEMA].
[[[NOTE FOR REVIEWERS: Some terms in
these namespaces have been deprecated, some have been added, and
some RDF schema terms have had their meaning changed. We invite
community feedback regarding the relative costs of adopting these
changes under the old namespace URIs vs creating new URIs for
this revision of RDF.]]]
Vocabulary terms in the rdf: namespace
are listed in section
5.1 of the RDF syntax specification [RDF-SYNTAX]. Some of these terms are defined by the RDF specifications to denote specific concepts. Others have purely syntactic purpose (e.g. rdf:ID is part of the RDF/XML syntax) and should not be used in RDF to denote any kind of resource.
Vocabulary terms defined in the rdfs:
namespace are defined in the RDF schema vocabulary specification [RDF-VOCABULARY].
Any information about URI references in the RDF and RDFS vocabularies (i.e. those that start with the RDF or RDFS namespace name) that is not supported by the RDF specifications (including possible future revisions and extensions) should not be taken to be correct in all uses of RDF.
RDF provides for XML content as a possible literal value. This
typically originates from the use of rdf:parseType="Literal"
in the RDF/XML Syntax [RDF-SYNTAX].
Such content is indicated in an RDF graph using a typed literal
whose datatype is a special built-in datatype, rdf:XMLLiteral.
As part of the definition of this datatype, an ancillary
definition is used.
The XML document corresponding to a pair ( str,
lang ) is formed as follows:
Concatenate the five strings:
- "<rdf-wrapper xml:lang='"
- lang
- "'>"
- str
- "</rdf-wrapper>"
Encode the resulting Unicode string in UTF-8 to form the
corresponding XML document.
No escaping is applied. The choice of rdf-wrapper
is fixed but arbitrary.
The XML document corresponding to a string str
is formed as the XML document corresponding to the pair (str,
"").
Using this, the datatype rdf:XMLLiteral is
defined as follows.
- The datatype URI
- is http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral.
- The value space
- is the set of all XML documents that:
- Have root element tag: <rdf-wrapper>
- Have no attributes on the root element other than xml:lang
- are
Canonical XML [XML-C14N] (with
comments).
- The lexical space
- contains all pairs ( string, lang ) where lang
is any language identifier [RFC-3066] in
lowercase, and string is well-balanced,
self-contained XML element content [XML],
for which the XML document corresponding to the pair is a well-formed
XML document [XML] that also conforms
to XML
Namespaces [XML-NS].
- also contains all strings string which
are well-balanced, self-contained XML element content [XML], and for which the corresponding XML document
is a well-formed
XML document [XML] that also conforms
to XML
Namespaces [XML-NS].
- The mapping
- is defined as the function that maps a pair or string to the canonical
form [XML-C14N] (with comments) of
the corresponding XML document.
Reminder: All other datatypes have a
lexical space being a set of strings, and a mapping which maps
strings to values.
Note: Not all values of this datatype
are compliant with XML 1.1 [XML 1.1].
If compliance with XML 1.1 is desired, then only those values
that are fully
normalized according to XML 1.1 should be used.
This section defines the RDF abstract syntax. The RDF abstract
syntax is a set of triples, called the RDF graph.
This section also defines equality between RDF graphs. A
definition of equality is needed to support the RDF Test Cases [RDF-TESTS] specification.
An RDF triple
contains three components:
An RDF triple is conventionally written in the order subject,
predicate, object.
The predicate is also known as the property of the triple.
An RDF graph
is a set of RDF triples.
The nodes of an RDF
graph is the set of subjects and objects of triples in the graph.
Two RDF graphs G and G' are equal if there
is a bijection M between the nodes of the two graphs,
such that:
- M(lit)=lit for all RDF literals lit
which are nodes of either graph.
- M(uri)=uri for all RDF
URI references uri which are nodes of either graph.
- The triple ( s, p, o ) is in G if and
only if the triple ( M(s), p, M(o) ) is in G'
With this definition, there are the same number of blank nodes in
the two graphs, and M shows how each blank node in G
can be replaced with a new blank node to give G'.
A URI
reference within an RDF graph (an RDF URI reference) is a
Unicode string [UNICODE] that:
- is in Normal Form C [NFC] and
- would produce a valid URI character sequence (per RFC2396 [URI], sections 2.1) when subjected to the
encoding described below.
The encoding consists of:
- encoding the Unicode string as UTF-8 [RFC-2279],
giving a sequence of octet values.
- %-escaping octets that do not correspond to permitted US-ASCII
characters.
The disallowed octets that must be %-escaped include all those that
do not correspond to US-ASCII characters, and the excluded characters
listed in Section 2.4 of [URI], except for the
number sign (#), percent sign (%), and the square bracket characters
re-allowed in [RFC-2732].
Disallowed octets must be escaped with the URI escaping mechanism
(that is, converted to %HH, where HH is the 2-digit hexadecimal
numeral corresponding to the octet value).
Two RDF URI references are equal if and only if they compare as
equal, character by character, as Unicode strings.
Editors' Note: This section is in the scope of
the TAG issue IRIEverywhere-27.
The editors are expecting a resolution of this issue during the
last call period. This may result in updates to this section.
Note: RDF URI references are compatible with the
anyURI datatype as defined by XML schema datatypes [XML-SCHEMA2], constrained to be an
absolute rather than a relative URI reference, and constrained to
be in Unicode Normal Form C [NFC] (for
compatibility with [CHARMOD]).
Note: RDF URI references are compatible with International Resource
Identifiers as defined by [XML
Namespaces 1.1].
Note: The restriction to absolute URI references is
found in this abstract syntax. When there is a well-defined base
URI, concrete syntaxes, such as RDF/XML, may permit relative URIs
as a shorthand for such absolute URI references.
A literal in
an RDF graph contains three components called:
The lexical form is present in all RDF literals; the language
identifier and the datatype URI may be absent from an RDF literal.
A plain
literal is one in which the datatype URI is absent.
A typed
literal is one in which the datatype URI is present.
Note: Literals in which the lexical form begins with
a composing character (as defined by [CHARMOD])
are allowed however they may cause interoperability problems,
particularly with XML version 1.1 [XML 1.1].
Note: When using the language identifier, care must
be taken not to confuse language with locale. The language
identifier only relates to human language text. Presentational
issues, how to best represent typed data to the end-user, should
be addressed in end-user applications.
Two literals are equal if and only if all of the following hold:
- The strings of the two lexical forms compare equal, character
by character.
- Either both or neither have language identifiers.
- The language identifiers of the two lexical forms compare
equal.
- Either both or neither have datatype URIs.
- The two datatype URIs, if any, compare equal, character by
character.
Note: RDF Literals are distinct and
distinguishable from RDF URI references; e.g. http://example.org
as an RDF Literal (untyped, without a language identifier) is not
equal to http://example.org as an RDF URI reference.
The datatype URI refers to a datatype.
For XML Schema
built-in datatypes, URIs such as http://www.w3.org/2001/XMLSchema#int
are used. The URI of the datatype rdf:XMLLiteral may be used. There may be other,
implementation dependent, mechanisms by which URIs refer to
datatypes.
The value associated with a typed literal is found by
applying the datatype mapping associated with the datatype URI to
the lexical form. Exceptionally, if the datatype is rdf:XMLLiteral and the
literal has a language identifier, then the datatype mapping is
applied to the pair form by the lexical form and the language
identifier.
If the lexical form is not in the lexical space of the datatype
associated with the datatype URI, then no literal value can be
associated with the typed literal. Such a case, while in error, is not syntacticly
ill-formed.
A typed literal for which the datatype does not map the lexical
form to a value is not syntacticly ill-formed.
Note: In application contexts,
comparing the values of typed literals (see section 6.5.2) is usually more
helpful than comparing their syntactic forms (see section 6.5.1). Similarly, for
comparing RDF Graphs, semantic notions of entailment (see [RDF-SEMANTICS]) are usually more helpful
than syntactic equality (see
section 6.3).
The blank nodes
in an RDF graph are drawn from an infinite set. This set of blank
nodes, the set of all RDF URI references
and the set of all literals are pairwise
disjoint.
Otherwise, this set is arbitrary.
RDF makes no reference to any internal structure of blank nodes.
RDF uses an RDF URI Reference, which may include a fragment identifier, as a context free identifier for a resource. RFC 2396 [URI]
states that the meaning of a fragment identifier depends on the
MIME content-type of a document, i.e. is context dependent.
These apparently conflicting views are reconciled by considering that a URI reference in an RDF graph is treated with respect to the MIME type application/rdf+xml [RDF-MIME-TYPE]. Given an RDF URI reference consisting of an absolute URI and a fragment identifier, the fragment identifer identifies the same thing that it does in an application/rdf+xml representation of the resource identified by the absolute URI component. Thus:
- we assume that the URI part (i.e. excluding fragment identifier) identifies a resource, which is presumed to have an RDF representation. So when eg:someurl#frag is used in an RDF document, eg:someurl is taken to designate some RDF document (even when no such document can be retrieved).
- eg:someurl#frag means the thing that is indicated, according to the rules of the application/rdf+xml MIME content-type as a "fragment" or "view" of the RDF document at eg:someurl. If the document does not exist, or cannot be retrieved, or is available only in formats other than application/rdf+xml, then exactly what that view may be is somewhat undetermined, but that does not prevent use of RDF to say things about it.
- the RDF treatment of a fragment identifier allows it to indicate a thing that is entirely external to the document, or even to the "shared information space" known as the Web. That is, it can be a more general idea, like some particular car or a mythical Unicorn.
- in this way, an application/rdf+xml document acts as an intermediary between some Web retrievable documents (itself, at least, also any other Web retrievable URIs that it may use, possibly including schema URIs and references to other RDF documents), and some set of possibly abstract or non-Web entities that the RDF may describe.
This provides a handling of URI references and their denotation that is consistent with the RDF model theory and usage, and also with conventional Web behavior. Note that nothing here requires that an RDF application be able to retrieve any representation of resources identified by the URIs in an RDF graph.
This document contains a significant contribution from Pat
Hayes, Sergey Melnik and Patrick Stickler, under whose leadership
was developed the framework described in the RDF family of
specifications for representing datatyped values, such as integers
and dates.
The editors acknowledge valuable contributions from the
following: Frank Manola,
Pat Hayes, Dan Brickley, Jos
de Roo, Dave Beckett,
Patrick Stickler, Peter F. Patel-Schneider,
Jerome Euzenat, Massimo Marchiori,
Tim Berners-Lee, Dave Reynolds
and Dan Connolly.
Jeremy Carroll thanks Oreste
Signore, his host at the W3C
Office in Italy and Istituto di Scienza e Tecnologie dell'Informazione
"Alessandro Faedo", part of the Consiglio Nazionale delle Ricerche,
where Jeremy is a visiting researcher.
This document is a product of extended deliberations by the
RDFcore Working Group, whose members have included:
Art Barstow (W3C), Dave Beckett (ILRT),
Dan Brickley (ILRT), Dan Connolly (W3C),
Jeremy Carroll (Hewlett Packard), Ron Daniel
(Interwoven Inc), Bill dehOra (InterX),
Jos De Roo (AGFA), Jan Grant (ILRT),
Graham Klyne (Nine by Nine), Frank Manola (MITRE
Corporation), Brian McBride (Hewlett Packard),
Eric Miller (W3C), Stephen Petschulat (IBM),
Patrick Stickler (Nokia), Aaron Swartz (HWG),
Mike Dean (BBN Technologies / Verizon), R. V. Guha
(Alpiri Inc), Pat Hayes (IHMC),
Sergey Melnik (Stanford University) and Martyn
Horner (Profium Ltd).
This specification also draws upon an earlier RDF Model and
Syntax document edited by Ora Lassilla and Ralph Swick, and RDF
Schema edited by Dan Brickley and R. V. Guha. RDF and RDF Schema
Working Group members who contributed to this earlier work are:
Nick Arnett (Verity), Tim Berners-Lee (W3C),
Tim Bray (Textuality), Dan Brickley (ILRT /
University of Bristol), Walter Chang (Adobe),
Sailesh Chutani (Oracle), Dan Connolly (W3C),
Ron Daniel (DATAFUSION), Charles Frankston
(Microsoft), Patrick Gannon (CommerceNet),
R. V. Guha (Epinions, previously of Netscape Communications),
Tom Hill (Apple Computer), Arthur van Hoff
(Marimba), Renato Iannella (DSTC),
Sandeep Jain (Oracle), Kevin Jones, (InterMind),
Emiko Kezuka (Digital Vision Laboratories), Joe
Lapp (webMethods Inc.), Ora Lassila (Nokia
Research Center), Andrew Layman (Microsoft),
Ralph LeVan (OCLC), John McCarthy (Lawrence
Berkeley National Laboratory), Chris McConnell
(Microsoft), Murray Maloney (Grif),
Michael Mealling (Network Solutions), Norbert
Mikula (DataChannel), Eric Miller (OCLC),
Jim Miller (W3C, emeritus), Frank Olken (Lawrence
Berkeley National Laboratory), Jean Paoli
(Microsoft), Sri Raghavan (Digital/Compaq),
Lisa Rein (webMethods Inc.), Paul Resnick
(University of Michigan), Bill Roberts
(KnowledgeCite), Tsuyoshi Sakata (Digital Vision
Laboratories), Bob Schloss (IBM),
Leon Shklar (Pencom Web Works), David Singer (IBM),
Wei (William) Song (SISU), Neel Sundaresan (IBM),
Ralph Swick (W3C), Naohiko Uramoto (IBM),
Charles Wicksteed (Reuters Ltd.), Misha Wolf
(Reuters Ltd.) and Lauren Wood (SoftQuad).
9.1 Normative References
- [RDF-SYNTAX]
- RDF/XML
Syntax Specification (Revised), Dave Beckett, World Wide
Web Consortium, 8 November 2002 (work in progress). This version
of the RDF/XML Syntax Specification (Revised) is
http://www.w3.org/TR/2002/WD-rdf-syntax-grammar-20021108/. The
latest version is at http://www.w3.org/TR/rdf-syntax-grammar/.
- [RDF-SEMANTICS]
- RDF
Semantics, P. Hayes, World Wide Web Consortium,
12 November 2002 (work in progress). This version of the RDF
Semantics is http://www.w3.org/TR/2002/WD-rdf-mt-20021112/. The
latest version is at http://www.w3.org/TR/rdf-mt/.
- [RDF-VOCABULARY]
- RDF
Vocabulary Description Language 1.0: RDF Schema, Dan
Brickley, R.V. Guha, World Wide Web Consortium, April 2002 (work
in progress). This version of the RDF Vocabulary
Description Language is
http://www.w3.org/TR/2002/WD-rdf-schema-20021112/. The latest
version is at http://www.w3.org/TR/rdf-schema/.
- [RDF-MIME-TYPE]
-
Application/rdf+xml Media Type Registration, A. Swartz,
IETF Internet Draft, March 2002 (work in progress). Version
available at
http://www.ietf.org/internet-drafts/draft-swartz-rdfcore-rdfxml-mediatype-01.txt.
- [XML]
- Extensible
Markup Language (XML) 1.0, Second Edition, T. Bray, J.
Paoli, C.M. Sperberg-McQueen and E. Maler, Editors. World Wide
Web Consortium. 6 October 2000. This version is http://www.w3.org/TR/2000/REC-xml-20001006.
The latest version of XML is available at http://www.w3.org/TR/REC-xml.
- [XML-NS]
- Namespaces
in XML, T. Bray, D. Hollander and A. Layman, Editors.
World Wide Web Consortium. 14 January 1999. This version is http://www.w3.org/TR/1999/REC-xml-names-19990114/.
The latest version
of Namespaces in XML is available at
http://www.w3.org/TR/REC-xml-names/.
- [RFC-2279]
- RFC 2279
- UTF-8, a transformation format of ISO 10646, F.
Yergeau, IETF, January 1998. This document is
http://www.isi.edu/in-notes/rfc2279.txt.
- [URI]
- RFC
2396 - Uniform Resource Identifiers (URI): Generic Syntax,
T. Berners-Lee, R. Fielding and L. Masinter, IETF, August 1998.
This document is http://www.isi.edu/in-notes/rfc2396.txt.
- [HTTP]
- RFC
2616 - Hypertext Transfer Protocol -- HTTP/1.1, R.
Fielding, UC Irvine, J. Gettys, J. Mogul, H. Frystyk, L. Masinter, P.
Leach, T. Berners-Lee, IETF, August 1998. This document is
http://www.isi.edu/in-notes/rfc2616.txt.
- [URI-REG]
- RFC
2717 - Registration Procedures for URL Scheme Names,
R. Petke and I. King, IETF, November 1999. This document is
http://www.isi.edu/in-notes/rfc2717.txt.
- [RFC-2732]
- RFC 2732
- Format for Literal IPv6 Addresses in URL's, R. Hinden,
B. Carpenter and L. Masinter, IETF, December 1999. This document
is http://www.isi.edu/in-notes/rfc2732.txt.
- [UNICODE]
- The Unicode Standard, Version 3, The Unicode
Consortium, Addison-Wesley, 2000. ISBN 0-201-61633-5, as updated
from time to time by the publication of new versions. (See http://www.unicode.org/unicode/standard/versions/
for the latest version and additional information on versions of
the standard and of the Unicode Character Database).
- [NFC]
- Unicode
Normalization Forms, Unicode Standard Annex #15, Mark
Davis, Martin Dürst. (See http://www.unicode.org/unicode/reports/tr15/
for the latest version).
- [RFC-3066]
- RFC 3066
- Tags for the Identification of Languages, H.
Alvestrand, IETF, January 2001. This document is
http://www.isi.edu/in-notes/rfc3066.txt.
- [XML-C14N]
- Canonical
XML. J. Boyer. W3C Recommendation, March 2001.
- Available at http://www.w3.org/TR/2001/REC-xml-c14n-20010315
- Available at http://www.ietf.org/rfc/rfc3076.txt
- [XML-SCHEMA2]
- XML Schema
Part 2: Datatypes - W3C Recommendation, World Wide Web
Consortium, 2 May 2001.
9.2 Informational
References
- [RDF-TESTS]
- RDF Test
Cases, Jan Grant and Dave Beckett, Editors. Work in
progress. World Wide Web Consortium, 29 April 2002. This version
of the RDF Test Cases is http://www.w3.org/TR/2002/WD-rdf-testcases-20021112/.
The latest version of the RDF Test Cases is at http://www.w3.org/TR/rdf-testcases/.
- [RDF-PRIMER]
- RDF
Primer, F. Manola, E. Miller, Editors, World Wide Web
Consortium W3C Working Draft, work in progress, 26 April 2002.
This version of the RDF Primer is
http://www.w3.org/TR/2002/WD-rdf-primer-20020426/. The latest version of the RDF
Primer is at http://www.w3.org/TR/rdf-primer/.
- [CHARMOD]
- Character
Model for the World Wide Web 1.0, M. Dürst, F.
Yergeau, R. Ishida, M. Wolf, A. Freytag, T Texin, Editors, World
Wide Web Consortium Working Draft, work in progress, 20 February
2002. This version of the Character Model is
http://www.w3.org/TR/2002/WD-charmod-20020220/. The latest version of the Character
Model is at http://www.w3.org/TR/charmod/.
- [XML-1.1]
- Extensible Markup
Language (XML) 1.1, John Cowan, Editor. World Wide Web
Consortium Working Draft 25 April 2002. (Work in progress)
- [XML-NAMESPACES-1.1]
- Namespaces
in XML 1.1, Tim Bray, Dave Hollander, Andrew Layman,
Richard Tobin, Editors. World Wide Web Consortium Working Draft 5
September 2002. (Work in progress)
- [XML-INFOSET]
- XML
Information Set, John Cowan and Richard Tobin, W3C
Recommendation, 24 October 2001. This document is
http://www.w3.org/TR/xml-infoset/.
- [OWL]
- OWL
Web Ontology Language 1.0 Reference, Mike Dean, Dan
Connolly, Frank van Harmelen, James Hendler, Ian Horrocks,
Deborah L. McGuinness, Peter F. Patel-Schneider, and Lynn Andrea
Stein. W3C Working Draft 29 July 2002. Latest version is
available at http://www.w3.org/TR/owl-ref/.
- [SOWA]
- Knowledge Representation: Logical, Philosophical and
Computational Foundations, John F. Sowa, Brookes/Cole, 2000.
ISBN 0-534-94965-7.
- [RDF-MS]
- Resource
Description Framework (RDF) Model and Syntax Specification,
O. Lassila and R. Swick, Editors. World Wide Web Consortium. 22
February 1999. This version is
http://www.w3.org/TR/1999/REC-rdf-syntax-19990222/. The latest version of RDF
M&S is available at http://www.w3.org/TR/REC-rdf-syntax/.
- [RDF-SCHEMA]
-
Resource Description Framework (RDF) Schema Specification 1.0,
Dan Brickley and R. V. Guha, W3C Candidate Recommendation, 27
March 2000. This document is
http://www.w3.org/TR/2000/CR-rdf-schema-20000327/.
- pfps-14
- Deleted section 4 about social meaning. Also removed previous section 2.2.8 ("A Basis for Binding Agreements") as this also related to social meaning. (The discusssion of this issue suggests there may be aspects of pfps-14 not fully addressed by this change, but I don't see any further changes to make in this document). Also removed mention in section 3.3. about the defining authority of a datatype URI.
- (No formal issue)
- Renamed previous section 3.7 to section 4, as it doesn't really seem to belong in "Concepts" (and to minimize renumbering of the document). Also changed "namespace URI" to "namespace name", to be more consistent with XML namespace termonology.
- macgregor-01, macgregor-02
- These issues, about distinguishing asserted and non-asserted statements and propositional attitudes, are addressed by the removal of section 4, which raised doubts about their inclusion in RDF.
- pfps-16
- Deleted section 2.2.7 (which didn't say anything not already covered by section 2.2.6), revised title and wording of section 2.2.6. Also, the changes to section 3.5 noted above remove explicit reference to expressive power, but rather address some kinds of information that RDF might be used to express.
- pfps-22, pfps-23
- Revised text in section 4 to clarify role of RDF(S) vocabulary. Also changed term "URI" to "URI reference".
- williams-01
- Rework text in section 3.2 to be more consistent with view of URIs as nodes (rather than node labels). Included revised introduction of node concept in section 3.1. Used some of Pat Hayes' suggested text in section 3.1. Also some impact on rewording in section 2.2.6. Some further small reworking of sections 3.1, 3.2 in response to RDFcore mailing list comments.
- (No formal issue)
- Reworked text in section 7 to clarify its intent, and added note that retrieval of resource representation is not required . This in response to last-call comments from Stuart Williams and Massimo Marchiori.
- (No formal issue)
- Section 3.1, replace use of "property" by "predicate". SImilarly, other uses throughout the document. The term "property" still appears, but "predeicate" is now used as the lead term.
- issue-xxx
- xxxx
$Log: Overview.html,v $
Revision 1.21 2003/04/11 14:00:21 graham
Update revision history.
Edit version to be proposed to 2003-04-11 telecon.
Revision 1.20 2003/04/11 13:25:46 graham
Changed use of "property" to prefer "predicate".
Edit version to be proposed to 2003-04-11 telecon.
Revision 1.19 2003/04/11 12:55:48 graham
Worked in revisions based on RDFcore list discussions.
Edit versions to be proposed to 2003-04-11 telecon.
Revision 1.18 2003/04/04 15:05:08 graham
Revise wording of sections 3.1, 3.2 to fix some problems noted.
Revision 1.17 2003/04/04 13:29:12 graham
Clarified text (URI fregmants) in section 7.
Revision 1.16 2003/04/03 18:18:38 graham
Update revision summary.
Revision 1.15 2003/04/03 18:17:29 graham
Incorporated some of Pat's suggested text into section 3.1,
further clarifying the role of URIs in RDF graphs.
Revision 1.14 2003/04/03 17:57:47 graham
Fix section 3.1 heading in ToC
Revision 1.13 2003/04/03 17:53:50 graham
Reworked text in 3.1, 3.2 to address williams-01,
clarifying role of URIs and literals in an RDF graph.
Revision 1.12 2003/04/03 16:55:49 graham
Rework of revised section 4 text.
Revision 1.11 2003/04/03 16:46:43 graham
Revise/add text in section 4 to describe role of RDF(s) vocabularies.
Revision 1.10 2003/04/02 20:48:38 graham
Further revision to text in section 2.2.6.
Revision 1.9 2003/04/02 20:42:29 graham
Fix problem with revised text in section 2.2.6.
Revision 1.8 2003/04/02 20:34:45 graham
Removed two paragraphs added to section 3.5 (cf. rev 1.2)
Revision 1.7 2003/04/01 18:40:32 graham
More wording changes in section 2.2.6, and ToC fix
Revision 1.6 2003/04/01 18:34:45 graham
Fix up section 2.2.6 heading in ToC
Revision 1.5 2003/04/01 18:26:29 graham
Deleted section 2.2.7 from ToC
Revision 1.4 2003/04/01 18:24:26 graham
Deleted section 2.2.7 and revised wording in 2.2.6
Revision 1.3 2003/04/01 17:32:38 graham
Add extra paragraph at start of section 3.5 to capture sense of
"Shelley's Words of Wisdom" noted by Pat Hayes.
Revision 1.2 2003/04/01 16:30:24 graham
Remove section on social meaning
Renumber section about namespace URIs and vocabularies
Replace part of section 3.5 with a reference to the primer,
and add two short paragraphs clarifying non-support for
propositional attitudes and distinction between asserted and
non-asserted statements.
***
