Resource Description Framework (RDF)
Editors' Working Draft 27 June 2002
- This version:
- http://www.ninebynine.org/wip/RDF-basics/2002-06-27/Overview.htm
- Latest version:
- http://www.ninebynine.org/wip/RDF-basics/Current/Overview.htm
- Previous version:
- http://www.ninebynine.org/wip/RDF-basics/2002-06-24/Overview.htm
- Editors:
- Graham Klyne (Clearswift and Nine by Nine)
- Jeremy Carroll (Hewlett Packard Labs)
- Series editor:
- Brian McBride (Hewlett Packard Labs)
Copyright ©2002 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
Abstract
[[[tbd]]]
Status of this Document
The following text refers to the intended status of this document: it has not yet been approved by the RDF core working group or W3C director and has no status other than editors' working draft at this time.
This is a W3C RDF Core Working Group Working Draft produced as part of the W3C Semantic Web Activity (Activity Statement).
This document is being released for review by W3C Members and other interested parties to encourage feedback and comments, especially with regard to how the changes affect existing implementations and content.
This is a public W3C Working Draft and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite as other than "work in progress". A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR/.
Comments on this document are invited and should be sent to the public mailing list www-rdf-comments@w3.org. An archive of comments is available at http://lists.w3.org/Archives/Public/www-rdf-comments/.
Table of contents
- 1. Introduction
- 2. RDF overview
- 3. RDF specification
- 4. Graph syntax
- 5. RDF vocabulary intended semantics
- 6. Additional technical considerations
- 7. Acknowledgments
- 8. References
Appendices
1. Introduction
[[[tbd -- about this document]]]
xxx
2. RDF overview
RDF is a data format for representing metadata about Web resources, and other information. It uses well established ideas from various data and knowledge representation communities, with recognizable relationships to Conceptual Graphs, logic-based knowedge representation, frames, and relational databases [Sowa,CG,KIF,Hayes,Luger,Gray].
RDF builds on XML, which provides a syntactic framework for representing documents and other information. It has a simple graph-based data model and formal semantics with a rigorously defined notion of entailment, which in turn provides a basis for well founded deductions in RDF data.
The real value of RDF comes not so much from any single application, but from the possibilities for sharing data between applications. The value of information thus increases as it becomes accessible to more and more applications across the entire Internet.
2.1 Motivation
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 formats (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 between 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.
2.2 Design goals
The design of RDF is intended to meet the following goals:
- A simple data model
- Formal semantics and well-founded inference
- Extensible URI-based vocabulary
- XML-based syntax
- Use XML schema datatypes
- Anyone can say anything about anything
- A basis for legally binding agrements
- Universal expression of ground facts
2.2.1 A simple data model
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 model theory specification [RDF-SEMANTICS] or a textbook on logical semantics (e.g. [HUNTER,DAVIS]) for more information about what logicians call "model theory".
2.2.2 Formal semantics and well-founded inference
RDF has a formal semantics which provides a sound 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.
2.2.3 Extensible URI-based vocabulary
The vocabulary is fully extensible, being based on URIs with optional fragment identifiers (URIrefs). URIrefs are used for naming all kinds of things in RDF data. The only other kind of label that appears in RDF data is a literal string.
2.2.4 XML-based syntax
RDF has an XML-based serialization form which, if used appropriately, allows a wide range of "ordinary" XML data to be interpreted as RDF [STRIPEDRDF].
2.2.5 Use XML schema datatypes
RDF can be used with XML schema datatypes [XML-SCHEMA2], thus assisting the exchange of information between RDF and other XML applications.
[[[Add comment here if goal not fully achieved]]]
2.2.6 Anyone can say anything about anything
To allow operation at Internet scale, RDF is an open-world framework that allows anyone to say anything about anything. In general, it is not assumed that all information about any topic is available. A consequence of this is that RDF cannot prevent anyone from making nonsensical or inconsistent assertions, and applications that build upon RDF must find ways to deal with conflicting sources of information. (This is where RDF departs from the XML approach to data representation, which is generally quite prescriptive and aims to present an application with information that is well-formed and complete for the application's needs.)
2.2.7 Universal expression of ground facts
Through its use of extensible URI-based vocabularies, RDF aims to provide for universal expression of ground facts; i.e. assertions of specific properties about specific named things.
RDF itself does not provide the machinery of inference, but provides the raw data upon which such machinery can operate. Other work is looking for ways to build more expressive expressions on the basic capabilities of the RDF core language.
2.2.8 A basis for binding agrements
RDF is intended to convey assertions that are meaningful to the extent that they may, in appropriate contexts, be used to express the terms of binding agreements.
This goal is explored further in section 2.3 below.
2.3 Meaning of RDF documents
The RDF specification emphasizes the formal structure and meaning of RDF. But there is also a social dimension that is easily overlooked when dealing with such formal aspects.
2.3.1 Formal semantics
[[[These words adapted from Primer 7.1]]]
RDF is a language designed to support the Semantic Web, in much the same way that HTML is the language that supports the original Web. The Semantic Web aims for data to be shared and processed by automated tools as well as by people. To serve this purpose, certain meanings of RDF statements must be defined in a very precise manner; this is provided by the RDF Model Theory [RDF-SEMANTICS].
Model-theoretic semantics assumes that a language refers to a 'world', and describes the minimal conditions that a world must satisfy in order to assign an appropriate meaning for every expression in the language. A particular world is called an interpretation, so that model theory might be better called 'interpretation theory'. The idea is to provide an abstract, mathematical account of the properties that any such interpretation must have, making as few assumptions as possible about its actual nature or intrinsic structure. The RDF model theory is couched in the language of set theory simply because that is the normal language of mathematics - for example, the model theory assumes that names denote things in a set IR called the 'universe' - but the use of set- theoretic language is not supposed to imply that the things in the universe are set-theoretic in nature.
The chief utility of such a semantic theory is not to suggest any particular processing model, or to provide any deep analysis of the nature of the things being described by the language (in our case, the nature of resources), but rather to provide a technical tool to analyze the semantic properties of proposed operations on the language; in particular, to provide a way to determine when they preserve meaning.
The RDF model theory treats RDF as a simple assertional language, in which each triple makes a distinct assertion, and the meaning of any triple is not changed by adding other triples. Based on the semantics defined in the model theory, it is simple to translate an RDF graph into a logical expression with essentially the same meaning.
2.3.2 Social meaning
[[[Adapted words from DanBri/PatHayes]]]
RDF/XML documents, i.e. encodings of RDF graphs, can be used to make representations of claims or assertions about the world. RDF graphs may be asserted to be true, and such an assertion should be understood to carry the same social import and responsibilities as an assertion in any other format. A combination of social (e.g. legal) and technical machinery (protocols, file formats, publication frameworks) provide the contexts that fix the intended meanings of the vocabulary of some piece of RDF, and which distinguish assertions from other uses (e.g. citations, denals or illustrations).
A media type, application/rdf+xml has been registered for indicating the use of RDF/XML as an assertional representation in this way (see section 3.7).
2.3.3 Interaction between social and formal meaning
To support logical entailments, formal RDF meaning is based on a model theory (see section 2.3.1). The notion of truth here is crucial: a possible world may correspond to some RDF if and only if the RDF statement is true in that world. This leads to consideration of what makes a statement be true:
- logical truths: statements which are true (in any MT interpretation) completely by view of their grammatical form and formal interpretation rules of the language. These statements actually tell you nothing about the real world, as they are logically true of all possible worlds;
- assumed truths; roughly, according to Quine [QUINE] "statements that a native speaker of the language would regard as obvious". These might be regarded as axioms of the native speaker's world. In general, these will be truths that cannot be obtained by purely logical means, but rather are assessed by social means and institutions;
- assumed deductions: determined by some informal process (assumed to be valid) from some other truths that have already been accepted;
- mixed truths: truths that can be determined by some logical entailment from some other truths that have already been accepted.
It is presumed here that any interesting statement about the world or human afairs must ultimately depend on assumed truths. Having accepted such an assumed truth into one's worldview, other interesting truths may be deduced by logical means. Semantic web vocabulary gains currency through use, so also do semantic web deductions ultimately have force through acceptance by people. There is a combination of logical and social (non-logical) dimensions in which semantic web deduction must operate.
The RDF code language provides a way to make simple formal assertions, with very no machinery for formalizing allowable inferences. Inferences are performed by processes, embedded in software implentations, whose validity is not formally demonstrable, and must be assumed or trusted to be valid (in relation to the world and/or human affairs). It is expected that semantic web languages layered on RDF will give formal expression to allowable inference, and to allow provable deductions by generic software modules to replace the individual ad-hoc implemenations.
2.3.4 Implications of asserting RDF
When an RDF graph is asserted in the web, its publisher is saying something about their view of the world. (The mechanism for deciding whether or not a graph is asserted is not defined here, but it is presumed that the publisher's intent will be clear in some way -- social convention or logical deduction.)
When a user invokes an application, there is also a social and technical context of invocation that determines some set of RDF assertions that will be assumed to be true: the application itself, and any RDF files that are passed to it. Garbage-in, garbage-out applies: if the initial assumed facts are wrong or meaningless, the results will have little value. No specfic mechanisms for deciding or evaluating the validity of any such assertions are defined here.
An assertion tells us something about "the world" and human affairs, through the normal model theoretic possible-world constraint mechanisms. Some of the truths that are asserted may be logical truths that can be evaluated using logical machinery. Others may be assumed truths that cannot be evaluated logically, but can be determined by human interpretation. So when we assert an RDF graph, one is stating a constraint on the real world, saying that both the logically testable and humanly interpretable truths in the graph are indeed true in that world.
In accordance with appropriately sanctioned logical entailment, it is intended that inferences may be used to deduce new RDF statements with the same force of assertion as the explicitly statements from which they are derived.
Noting that there is no single human opinion about the truth of some statements, the graph may further contain commentary for human interpreters to indicate the realm of human interpretation that should be applied. This means a graph may contain "defining information" that is opaque to logical reasoners. This information may be used by human interpreters of RDF informaton, or programmers writing software to perform specialized forms of deduction in the Semantic Web.
2.4 RDF concepts
RDF uses the following key concepts:
- Graph data model
- URI-based vocabulary
- XML serialization syntax
2.4.1 Graph data model
The underlying structure of any RDF expression is a directed labelled graph (or multigraph), which consists of nodes and labelled directed arcs that link pairs of nodes. The formal semantics for RDF is defined in terms of this graph syntax. An RDF expression is sometimes called an RDF graph. The graph can conveniently be represented as a set of triples, where each triple contains two node labels and an arc label:
Each arc corresponds to a startement that asserts a relationship between the nodes that it links. The meaning of an RDF graph is the conjunction (i.e. logical AND) of all the statements that it contains.
2.4.2 URI-based vocabulary
Nodes in an RDF graph are labelled with URIs with optional fragment identifiers (URIrefs), literal strings, or nothing at all. Arcs are labelled with URIrefs.
The label on a node indicates what that node is meant to represent. The label on an arc names the relationship that is asserted to hold between the nodes connected by that arc. Some URIrefs may indicate web resources, and a node thus labelled is presumed to denote that resource. Other URIrefs may represent abstract ideas or values rather than a retreivable Web resource. RDF thus leverages the universal naming space of URIs [URIS].
2.4.3 XML serialization syntax
RDF has a specific serialization syntax based on XML. There are several ways in which a given RDF graph can be prepresented in XML: these various forms allow RDF to be represented in ways that are amenable to specific XML applications. In this way, XML application data can easily be designed to be accessible to generic RDF processors [XML-AS-RDF].
Other syntaxes for RDF graphs are possible (e.g. [NOTATION3]), but only the XML syntax is normatively specified and recommended for use to exchange information between Internet applications.
3. RDF specification
The RDF specification defines the following components:
- RDF core URI vocabulary and namespaces
- Graph syntax
- Formal semantics
- XML serialization syntax
- RDF Schema vocabulary definition language
- Datatypes [[[subject to finalization]]]
- MIME type registration: application/rdf+xml
Further, the RDF documentation suite contains:
- Test cases
- Primer
3.1 RDF core URI vocabulary and namespaces
RDF uses URIs to label resources and properties. Certain URIs are reserved for use by RDF, and may not be used for any purpose not sanctioned the RDF specifications. Specifically, URIs with the following leading substrings are reserved for RDF core vocabulary:
- http://www.w3.org/1999/02/22-rdf-syntax-ns# (conventionally associated with prefix rdf:)
- http://www.w3.org/2000/01/rdf-schema# (conventionally associated with prefix rdfs:)
Used with the RDF/XML serialization, these URI prefix strings correspond to XML namespaces [XML-NS] associated with the RDF core vocabulary terms.
NOTE: these namespace URIs are the same as those used in earlier RDF documents [RDF-MS, RDF-SCHEMA]. The URIs have not been updated because the working group feels its work has been to clarify the earlier work rather than to change it.
3.1.1 RDF defined vocabulary terms
The vocabulary terms are listed here using QName syntax. The corresponding URI reference is formed by concatenating the URI corresponding to the prefix (see above) with the given local name.
- rdf:RDF
- rdf:Description
- rdf:ID
- rdf:about
- rdf:resource
- rdf:parseType
- rdf:type
- rdf:Bag
- rdf:Seq
- rdf:Alt
- rdf:li
- rdf:_n (for decimal numerals n)
- rdf:Statement
- rdf:Property
- rdf:subject
- rdf:predicate
- rdf:object
- rdf:bagID
- rdf:value
- rdfs:Resource
- rdfs:Class
- rdfs:ConstraintResource
- rdfs:ConstraintProperty
- rdfs:Literal
- rdfs:subClassOf
- rdfs:subPropertyOf
- rdfs:comment
- rdfs:label
- rdfs:seeAlso
- rdfs:isDefinedBy
- rdfs:range
- rdfs:domain
- rdfs:Container
- rdfs:ContainerMembershipProperty
- rdfs:member
Informal descriptions of these terms are given in section 5 of this document. Where formal semantics are defined, they are given in the RDF formal semantics document [RDF-SEMANTICS].
Some of the above vocabulary terms are used for purely syntactic purposes in the RDF/XML serialization, and do not appear in the abstract graph syntax (see section 4.1). Any other use of these names is considered to be an error.
Other names from the rdf: and rdfs: namespaces (i.e. starting with one of the URI strings noted above) should be used only if they are defined by the RDF specification. Processors encountering unrecognized names in these namespaces should issue a warning, then continue to process them as any other vocabulary.
3.1.2 RDF deprecated vocabulary
The following RDG core vocabulary terms defined in previous RDF specification documents have been deprecated for future use:
- rdf:aboutEach
- rdf:aboutEachPrefix
- rdfs:ConstraintResource
- rdfs:ConstraintProperty
3.2 Graph syntax
RDF is based on a graph syntax, which is typically serialized using XML. This graph syntax captures the fundamental structure of RDF, independently of any serialization syntax that may be used. The formal semantics of RDF are defined in terms of the graph syntax.
A full description of the RDF graph syntax is given in section 4 of this document.
3.3 Formal semantics
[[[is there some overlap here?]]]
The formal semantics of RDF are presented in [RDF-SEMANTICS].
This formal semantics document specifies the essential elements of RDF abstract syntax, and the associated model theoretic semantics. The syntax is specified in a terms of a directed labelled graph and an equivalent representation of <subject,predciate,object> triples. Also given are entailment lemmas and their proofs. The entailment lemmas form the basis of RDF-based deduction. Building on the core language and semantics, this document also provides formal meaning for the RDF reserved vocabulary (URIrefs) for RDF schema, also with model theoretic semantics, entailment lemmas and proofs.
The formal semantics document contains a fair amount of formal mathematical content, necessary to meet some of the stated goals for RDF. Because RDF is such a simple language, the document actually serves as a quite accessible introduction to model theoretical formal semantics. Developers whose sole concern is to write software that processes RDF may prefer to work from the XML syntax and RDF schema specifications, referring to this formal semantics specification to resolve occasional questions about validity of deductions.
3.4 XML serialization syntax
The RDF XML Syntax document [RDF-SYNTAX] defines the XML serialized forms for RDF graphs. The XML syntax is described in terms of the XML infoset [XML-INFOSET], and its correspondence to RDF graph triples.
Other serializations of an RDF graph are possible, but the XML serialization syntax is the only one recommended for exchanging RDF between applications.
3.5 RDF Schema vocabulary definition language
The RDF Schema document [RDF-VOCABULARY] introduces and describes the use of RDF schema vocabularies used to introduce names for properties and classes of things described by RDF. (The formal aspects of vocabulary introduced by this document are covered in the formal semantics document [RDF-SEMANTICS].)
3.6 RDF datatyping
[[[subject to finalization of datatyping]]]
Nodes in an RDF graph may be URI references (URIrefs), blank nodes or literals. URI references and blank nodes refer to resources that may be further described using RDF properties.
Literals are presumed to denote well-understood values. RDF datatyping provides a means to associate any literal in an RDF graph with a corresponding datatype, which refers to rules for interpretation of the literal. The datatyping rules are externally defined; i.e. not contained within the RDF graph, and presumed to be known to an RDF application by some means not specified here. Typically, knowledge of common datatypes is build into an RDF application.
The RDF datatyping framework is described in [RDF-DATATYPES].
3.7 MIME content type registration
As noted above in section 2.3.2, RDF may be used by a publisher to assert statements about the world. A MIME content-type, application/rdf+xml, is defined for labelling such uses of RDF when they are presented in MIME encapsulation.
The MIME type registration document is [RDF-MIME-TYPE].
3.8 Test cases
RDF Test Cases [RDF-TESTS] provide specific examples of XML syntax and the corresponding RDF graph triples. A particular syntax for RDF graph triples, which is a simplified variant of Notation 3 [NOTATION3], has been used to describe RDF graphs in a very direct and intuitive fashion. The test cases themselves are published in machine-readable form at referenced Web locations, so developers may use these as the basis for some automated testing of RDF software.
The test cases also contain a number of entailment tests, which indicate entailments that are licensed by the RDF specification for applications to use as the basis of deductions in RDF data. Many of these entailments relate to inferences that can be drawn from RDF schema and RDF datatyping information.
The test cases are not a complete specification of RDF, and are not intended to take precedence over the main specification documents. However, they do illustrate the intent of the working group with respect to the design of RDF, and developers may find them helpful should the specification wording be unclear on any point of detail.
3.9 Primer
The RDF Primer [RDF-PRIMER] serves two purposes:
- it provides a tutorial introduction to RDF, and
- it offers advice, particularly to RDF information designers, about how RDF is expected to be used to represent different kinds of information.
4. Graph syntax
This section defines the RDF graph syntax. The RDF graph is sometimes referred to as the (data) model of RDF (see the RDF Primer [RDF-PRIMER], and RDF Model & Syntax [RDF-MS]). In brief, the RDF graph is a directed graph with labelled edges and partially labelled nodes.
A goal of this section is the precise definition of equality between RDF graphs. This benefits interoperability (two conformant implementations are more likely to be practically interoperable if they have a precise conception of the way in which they are the same). It is required for the specification of the RDF Test Cases [RDF-TESTS], which depend on testing equality of RDF graphs for their execution. It is required by the RDF Model Theory [RDF-SEMANTICS] which assigns the same meaning to any pair of equal RDF graphs. [[[delete last sentence, and next para?]]]
Note: Many RDF applications and frameworks do not need to implement RDF graph equality. They do need to respect equality when assigning meaning to RDF graphs. RDF recommendations do not define conformance or compliance levels.
The specification of the RDF graph commences with the labels used in the graph, which can be uri references, string literals, or XML literals; equality is defined for each. It then proceeds to describing arcs (triples), a complete graph and graph equality.
[[[Need to go through the following, revising text to reflect precisely the things which *are* nodes vs things that *label* graph nodes. Also, check test case references.]]]
4.1 URI References
Within an RDF graph, URI reference labels are drawn from the lexical space of the anyuri datatype as defined for XML schema datatypes [XML-SCHEMA2], constrained to be an absolute rather than a relative URI reference, and to be in Unicode Normal Form C [NFC] in conformance with [CHARMOD].
Precisely, a URI Reference Label within an RDF graph is a Unicode string [UNICODE] that:
- is in Normal Form C [NFC] and
- would produce a US-ASCII string that is an absolute URI reference in the form defined by [URIS] as modified by [RFC-2732], when:
- encoded in UTF-8, and
- with disallowed characters escaped according to the percent escaping algorithm below
The characters that must be %-escaped include all non-ASCII characters, the excluded characters listed in Section 2.4 of [URIS], except for the number sign (#) and percent sign (%) characters and the square bracket characters re-allowed in [RFC-2732]. These must be escaped as follows:
Each disallowed character is converted to UTF-8 [RFC-2279] as one or more bytes.
- Any octets corresponding to a disallowed character are escaped with the URI escaping mechanism (that is, converted to %HH, where HH is the hexadecimal notation of the byte value).
- The original character is replaced by the resulting character sequence.
Two URI reference labels within RDF are equal if and only if they compare as equal, character by character, as Unicode strings. A URI reference label is not equal to a string literal label or an XML literal label.
See the following test cases, per [RDF-TESTS]:
- test001.rdf and test001.nt
- test004.rdf and test004.nt
4.2 RDF Literals
An RDF literal is either an XML literal or a string literal.
Two RDF literals are equal if and only if they are either both XML literals and equal or both string literals and equal.
4.2.1 String Literals
Within an RDF graph, a string literal is a Unicode string paired with a language identifier.
Two string literals are equal if both components are equal. The Unicode string components are compared on a character by character basis. The language tag components are equal if both are null or if both are defined and equal as language identifiers.
Note: This is compatible with the early uniform normalization processing model of [CHARMOD].
Allowable language identifiers are the legal values for xml:lang as specified by section 2.12, Language Identification, in [XML], or null. Equality of language identifiers (as specified in [RFC-3066]) is defined by case insensitive character by character comparison.
Note: This direct comparison between language identifiers is appropriate for the purpose of defining equality between RDF graphs, but is linguistically naive. [RFC-3066] suggests more advanced comparison techniques.
A string literal label in an RDF graph is composed of a Unicode string [UNICODE] that is in Normal Form C [NFC] and a language tag that is either null or as specified above.
[[[provide precise cross-ref above]]]
Note: Literals beginning 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].
See the following test cases, per [RDF-TESTS]:
- test001.rdf and test001.nt
- test004.rdf and test004.nt
4.2.2 XML Literals
Within an RDF graph, an XML literal is a Unicode [UNICODE] string paired with a language identifier. The string is an XML fragment, i.e. well-balanced, self-contained XML element content [XML].
Two XML literals are equal if both components are equal. Comparison of XML fragments is described below. The language identifiers are equal if both are null or if both are defined and equal as language identifiers, per [RFC-3066].
4.2.2.1 Equality of XML Fragments
An XML fragment is a Unicode string that when serialized between <tag> and </tag> [[[and encoded in UTF-8???]]] forms a well- formed XML document [XML].
Note: If compatibility with XML version 1.1 is desired, then XML fragments in RDF graphs must be restricted to those that are fully normalized according to [XML 1.1].
The definition of equality for XML fragments is not precisely defined by this specification. The description given here is used by the RDF Test Cases [RDF-TESTS], and also constrains any implementation defined equality.
Two XML fragments may be comparted by the following steps:
- Form an XML document from each fragment by enclosing it with <tag> and </tag> and encoding the resulting string in UTF-8.
- Take the exclusive canonicalization without comments [XC14N] of the element content of the root element of each document.
- Compare the two resulting UTF-8 strings byte by byte.
Implementations may specialize this definition of equality (i.e. if two XML fragments compare equal according to an implementation then they must compare equal according to this definition, but not conversely).
In particular, implementations may treat XML comments as significant, and may treat namespaces that are in scope but not visibly utilized (as defined by [XC14N]) as significant.
[[[I think the last para above maybe doesn't really belong here - #g]]]
[[[should this para be moved to a longer non-normative appendix which would have the goal of showing the DPH that they can do nearly nothing and still conform with this rather opaque requirement. @@@@ The use of character by character equality between XML fragments is discouraged, except in the case where XML fragments have already been canonicalized with an appropriate treatment of namespaces. @@@ would a test case showing where naivity is insuifficient be helpful, it would contain two character-by-character identical XML fragments which had qnames with namespace prefixes bound to different namespaces]]]
See the following test cases, per [RDF-TESTS]:
- test001.rdf and test001.nt
- test004.rdf and test004.nt
4.3 Nodes
A node in an RDF graph is one of the following:
- A URI reference (section 4.1 above)
- An RDF literal (section 4.2 above)
- A blank, or unlabelled, node
4.4 RDF triples
An RDF triple describes an arc in an RDF graph. It contains three components:
- a subject node (per section 4.3 above, but not a literal node),
- an predicate, labelling the arc, which is a URI reference (section 4.1 above), and
- an object node (per section 4.3 above).
Two RDF triples are equal if and only if their subjects are equal, their predicates are equal, and their objects are equal.
4.5 RDF graph
An RDF graph is a collection of RDF triples.
The nodes of an RDF graph are the set of nodes that are either subject or object of some triple in the graph.
The nodes of an RDF graph is a tidy set of nodes. [[[What does this mean?]]]
Note: The definition of an RDF graph diverges from the definition of a directed graph in a standard text such as [[[missing ref]]] in that: (a) all nodes must be in at least one arc; (b) all the arcs are labelled; (c) some of the nodes are labelled; (d) labels on nodes are required to be distinct; (e) some labels are shared between nodes and arcs. [[[Is this note helpful?]]]
4.6 Graph Equality
Two RDF graphs are equal if and only if they are isomorphic. An RDF graph isomorphism is a directed graph isomorphism that respects the labels on both arcs and nodes.
An RDF Graph isomorphism I between two graphs G and G' is a bijection between the nodes of G and the nodes of G', such that:
- I(n) is blank if and only if n is blank,
- the label (if any) on I(n) equals the label on n, and
- the triple ( I(s), p, I(o) ) is in G' if and only if the triple ( s, p, o ) is in G,
for all nodes n, s, o in G and all RDF URI references p.
@@@@ I note that I have used a system of typed objects with identity and with named components without introducing or defining it. (Notice that an XML Literal xml"foo"-"en" is distinct from a String Literal "foo"-"en"). Personally I think that introducing and defining such a system will confuse more than enlighten. I could be persuaded ...
4.7 Reserved URIs in graph syntax
The following elements of RDF vocabulary have syntactic significance only in the XML serialization, and never appear in the RDF abstract graph syntax:
- rdf:RDF
- rdf:Description
- rdf:ID
- rdf:about
- rdf:resource
- rdf:parseType
5. RDF vocabulary intended semantics
This section describes or references some additional intended semantics for certain RDF vocabulary terms, beyond those that can be expressed in the available RDF formalisms. None of these reverse anything that is specified by the RDF formal semantics. It is anticipated that future semantic web language developments will provide ways to formally express these additional intended semantics.
Some RDF applications may choose to incorporate these additional semantic constraints into their processing. By so doing, any valid RDF entailment is still a valid entailment, but such applications may offer some additional inferences that are not sanctioned by RDF entailments alone.
For example, an application may choose to consider rdf:Bag resources to be equivalent if they contain the same elements in any order; i.e. given:
_:x rdf:type rdf:Bag . _:x rdf:_1 <http://example.org/ItemA> . _:x rdf:_2 <http://example.org/ItemB> . _:y rdf:type rdf:Bag . _:y rdf:_1 <http://example.org/ItemB> . _:y rdf:_2 <http://example.org/ItemA> .
such an application might consider to be models only those RDF interpretations for which:
_:x prop obj <=> _:y prop obj
and
subj prop _:x <=> subj prop _:y
for all values of subj, prop and obj.
[[[Much of the following is already covered by RDF schema?]]]
5.1 Containers
To represent a collection of values, RDF uses an additional resource that denotes the collection. This resource may be declared to be an instance of one of the container object types defined below. The membership relation between this container resource and the resources that belong in the collection is defined by a set of properties defined expressly for this purpose. These membership properties are named rdf:_1, rdf:_2, rdf:_3, etc., which are all instances of class rdfs:ContainerMembershipProperty and subproperties of rdfs:member. Container resources may have any other properties in addition to membership properties and the rdf:type property. Any such additional statements describe the container.
RDF introduces three types of container objects:
- Bag (rdf:Bag)
- An unordered list of resources or literals. A bag contains multiple values, with no intended significance to the order in which the values are given. A bag might be used to give a list of part numbers where the order of processing the parts does not matter. Repeated values are permitted and are significant.
- Sequence (rdf:Seq)
- An ordered list of resources or literals. A sequence contains multiple values and that the order of the values is intended to be significant. A sequence might be used, for example, to preserve an alphabetical ordering of values. Duplicate values are permitted and are significant.
- Alternative (rdf:Alt)
- A list of resources or literals that represent alternatives from which a selection may be made. Detailed handling of this container type is very application dependent, and any inclination to use it as a logical disjunction should be resisted. An alternative container might be used to offer alternative language translations for the title of a work, or to provide a list of Internet mirror sites at which a resource might be found. An application using a property whose value is an alternative collection may choose any one of the contained values.
Note: The definitions of Bag and Sequence explicitly permit duplicate values. RDF does not have a core concept of Set, which would be like a Bag with no duplicates.
5.1.1 Containers and multiple properties
[[[This looks like primer material to me]]]
A resource may have multiple statements with the same predicate (i.e. using the same property). This is not the same as having a single statement whose object is a container containing multiple members. The choice of which to use in any particular circumstance is in part made by the person who designs the schema and in part made by the person who writes the specific RDF statements.
Consider as an example the relationship between a writer and her publications. We might have the sentence:
Sue has written "Anthology of Time", "Zoological Reasoning", and "Gravitational Reflections".
That is, there are three resources each of which was written independently by the same writer:
ex:Sue ex:publication <http://example.org/AnthologyOfTime> . ex:Sue ex:publication <http://example.org/ZoologicalReasoning> . ex:Sue ex:publication <http://example.org/GravitationalReflections> .
In this example there is no stated relationship between the publications other than that they were written by the same person. Each of the statements is true or false independently of the others.
But the sentence:
The committee of Fred, Wilma, and Dino approved the resolution.
says that the three committee members as a whole voted in a certain manner; it does not necessarily state that each committee member voted in favor of the article. It would be potentially misleading to model this sentence as three separate approvedBy statements, one for each committee member, as this could imply the vote of each individual member. Rather, it is better to model this as a single approvedBy statement whose object is a Bag containing the committee members' identities:
ex:resolution ex:approvedBy _:z _:z rdf:type rdf:Bag . _:z rdf:_1 ex:Fred . _:z rdf:_2 ex:Wilma . _:z rdf:_3 ex:Dino .
The choice of which representation to use, bag or repeated property, is made by the person creating the metadata after considering the schema. If, for example, in the publications example above we wished to say that those were the complete set of publications then the schema might include a property called publications for that purpose. The value of the publications property would be a bag listing all of Sue's works.
5.2 Reification
Reification vocabulary consists of rdf:Statement, rdf:subject, rdf:predicate and rdf:object. The use and limitations of reification are described in some detail in the RDF formal semantics document [RDF-SEMANTICS], section 3.2.1.
The intent of the reification vocabulary is to enable construction of information about instances of RDF statements: e.g. where they are published, when they were published, who published them, etc.
5.3 Textual annotations
Properties for providing textual annotations for RDF properties and classes are: rdfs:label and rdfs:comment. These are described in the RDF vocabulary description language document [RDF-VOCABULARY].
[[[The following is controversial...]]]
rdfs:comment can be used to provide human readable information about the intended use of an RDF property or class. While this information can have no standing to sanction formal RDF entailments, it may be used by humans who interpret RDF expressions containing the vocabulary thus described, or by software implementers who build software with special knowledge of the vocabulary terms.
[[[Can this vocabulary be used for resources other than classes and properties?]]]
5.4 Citations
Two properties are provided for referencing resources that may provide more information about an RDF class or property: rdfs:seeAlso and rdfs:isDefinedBy. These are described in the RDF vocabulary description language document [RDF-VOCABULARY].
[[[The following is controversial... ]]]
[[[These words are from f2f log ... maybe something like this will appear in the schema doc, and should then be deleted from here]]]
The rdfs:isDefinedBy property indicates a resource that contains information about the subject. Often, this property is used to indicate the source of the subject URI reference, where its owner specifies its intended meaning. The object of this property can be any URI reference, and may reference any document or resource; it is not restricted to indicating a particular form of schema.
The document referenced by this property does not affect the formal inferences that are possible using RDF, but may contain information for used by humans when interpreting the vocabulary thus described, or by software implementers who build software with special knowledge of the vocabulary terms.
[[[If an RDF document is referenced, can its contents be used?]]]
[[[Can this vocabulary be used for resources other than classes and properties?]]]
5.5 rdf:value
This property is described in the RDF vocabulary description language document [RDF-VOCABULARY].