WD-rdf-syntax-19980216Note: As working drafts are subject to frequent change, you are advised to reference the above URL for "Latest version" rather than the URLs for specific working draft versions themselves. The latest version URL will always point to the most current version of this draft.
Comments on this specification may be sent to www-rdf-comments@w3.org. The archive of public comments is available at http://www.w3.org/Archives/Public/www-rdf-comments.
Metadata is "data about data" or specifically in the context of RDF "data describing web resources". The distinction between "data" and "metadata" is not an absolute one; it is a distinction created primarily by a particular application. Many times the same resource will be interpreted in both ways simultaneously. RDF encourages this view by using XML as the encoding syntax for the metadata. The resources being described by RDF are, in general, anything that can be named via a URI. The broad goal of RDF is to define a mechanism for describing resources that makes no assumptions about a particular application domain, nor defines the semantics of any application domain. The definition of the mechanism should be domain neutral, yet the mechanism should be suitable for describing information about any domain.
This document introduces a model for representing RDF metadata and one syntax for expressing and transporting this metadata in a manner that maximizes the interoperability of independently developed web servers and clients. The syntax described in this document is best considered as a "serialization syntax" for the underlying RDF representation model. The serialization syntax uses the eXtensible Markup Language [XML]. RDF and XML are complementary; there will be alternate ways to represent the same RDF data model, some more suitable for direct human authoring. Future work may lead to including such alternatives in this document.
RDF expressions that are syntactically very different could mean the same thing. This concept of equivalence in meaning is very important when performing queries, aggregation and a number of other tasks at which RDF is aimed. The equivalence is defined in a clean machine understandable way. Two RDF expressions are equivalent if and only if their corresponding data model representations are the same. Two RDF string values (defined below) are deemed to be the same if their ISO/IEC 10646 representations match.
|
As RDF serialization is written in XML, the character repertoire of an RDF string is ISO/IEC 10646 [ISO10646]. An actual RDF string, whether in an XML document or in some other representation of the RDF data model, may be stored using a direct encoding of ISO/IEC 10646 or an encoding which can be mapped to ISO/IEC 10646. Language tagging is part of the string value; it is applied to sequences of characters within an RDF string and does not have an explicit manifestation in the data model.
Two RDF strings are deemed to be the same if their ISO/IEC 10646 representations match. Each RDF application must specify which one of the following definitions of 'match' it uses:
An RDF expression is represented pictorially in text with nodes in '[...]' and arcs in '--...-->' as follows:
[resource R] ---PropertyType P--> [value V]This is read "V is the value of the property type P for resource R", or left-to-right; "R has property type P with value V".
Consider as a simple example the statement:
[http://www.w3.org/People/Lassila] ---Author--> "Ora Lassila"where the notation '[URI]' denotes the node representing the resource identified by URI and quotation marks (") denote an atomic value.
According to the formal definition, this property, i.e. the arc labeled "Author" plus its source and target nodes, is the triple:
{Author, [http://www.w3.org/People/Lassila], "Ora Lassila"}
where "Author" denotes a node in PropertyTypes that corresponds
to this arc label.
A set of triples that all refer to the same node (the second item in the triple) can be grouped as a unit called a Description. Descriptions are particularly useful when specifying a number of properties of the same resource. A Description (here containing two properties) is diagrammed as follows:
[resource R] ---PropertyType P1--> [value Vp1] | ---PropertyType P2--> [value Vp2] [Bag B] --------RDF:1------------> [Property P1Vp1] | --------RDF:2------------> [Property P2Vp2]Each RDF Description has its own node (the node identified as "Bag B" in the diagram) identifying the collection of triples, as described below. The Description can therefore be described by properties; that is, a Description can itself be used as the source node of other arcs describing properties of the Description.
The property types in a given Description, as well as any characteristics or restrictions of the property values themselves, are defined by one or more schemas. Each property type used in a Description is declared to be from exactly one schema. A schema is identified by a URI. The schema URI may be treated merely as an identifier or it may refer to a machine-understandable description of the schema. By definition, to understand a particular schema used by a Description means to understand the semantics of each of the properties in that Description that are declared to be associated with the schema. An application that has no knowledge of the particular schema will still be able to parse the Description into the property type and property value components and will be able to transport the Description intact (e.g. to a cache or to another application).
The triple composed of a property type, a resource, and a value is an RDF property. Such a property can itself be the target node of an arc (i.e. the value of some other property) or the source node of an arc (i.e. it can have properties). In these cases, the original property must be reified; that is, converted into additional nodes and arcs. The term reification means to convert the relation expressed by the arc into a concrete node to which we can refer. Reification allows us to express modalities (e.g. beliefs about properties) or simply attach any properties to other properties.
For example, the reification of the expression
[http://www.w3.org/People/Lassila] ---Author--> "Ora Lassila"is the four properties
[X] ---InstanceOf--> [RDF:Property] [X] ---PropName----> [Author] [X] ---PropObj-----> [http://www.w3.org/People/Lassila] [X] ---Value-------> "Ora Lassila"That is, a node X and four new triples are added:
{InstanceOf, [X], [RDF:Property]}
{PropName, [X], [Author]}
{PropObj, [X], [http://www.w3.org/People/Lassila]}
{Value, [X], "Ora Lassila"}
Reified properties are drawn as a single node with several arcs emanating
from it representing the resource, property name, and value:
[property P1] ----InstanceOf-> [RDF:Property] | ----PropName---> [PropertyType P] | ----PropObj----> [resource R] | ----Value------> [value Vp1]This allows RDF to be used to make statements about other statements; for example, the statement "Ralph believes that the document 'The Origin of Species' was authored by Charles Darwin" is represented as:
[Ralph] --Believes--> [statement1] --InstanceOf-> [RDF:Property] | --PropName---> [Author] | --PropObj----> [http://loc.gov/Books/Species] | --Value------> "Charles Darwin"To help in reifying properties, RDF defines the InstanceOf relation (property type) to provide primitive typing, as shown in the previous example.
The formal definition of InstanceOf is:
|
|
Frequently it is necessary to create a collection of nodes; for example to state that a property has an ordered sequence of values. RDF defines three kinds of collections: ordered lists of nodes, called Sequences, unordered lists of nodes, called Bags, and lists that represent alternatives for the (single) value of a property, called Alternatives.
Formally, these three collection types are defined by:
|
A human- or machine-understandable description of an RDF schema may be accessed through content negotiation by dereferencing the schema URI. If the schema is machine-understandable it may be possible for an application to learn some of the semantics of the property types named in the schema on demand. The logic and syntax of RDF schemas are described in a separate document; "RDF Machine Understandable Schemas" (in progress).
This specification does not define any schemas; all references in this document to specific schema URIs and associated property types are intended as illustration only.
The syntax descriptions below use the Extended Backus-Naur Form notation as defined in section 6, Notation, of [XML] to describe the essential RDF syntax elements. The EBNF here is condensed for human readability; in particular, the italicized "rdf" is used to represent a variable namespace name rather than the more precise BNF notation "'<' NSname ':...'" and the requirement that the property and type names in end-tags exactly match the names in the corresponding start-tags is implied by the XML rules. As RDF is written using XML, all syntactic flexibilities of XML are also implicitly included; e.g. whitespace rules, quoting using either single quote (') or double quote ("), character escaping, case sensitivity, language tagging, etc. RDF requires the XML namespace facility, currently under review by the XML Working Group, to associate the schema, by way of its URI, with the properties in the Description.
This specification defines two syntaxes for encoding an RDF data model instance. The serialization syntax expresses the full capabilities of the data model in a very regular fashion. The abbreviated syntax includes additional constructs that provide a more compact form to represent a subset of the data model. Conformant RDF interpreters are expected to implement both the full serialization syntax and the abbreviated syntax.
[1] RDF ::= '<rdf:RDF>' expression* '</rdf:RDF>' [2] expression ::= description | collection [3] description ::= '<rdf:Description' idRefAttr? bagIdAttr? '>' property* '</rdf:Description>' [4] collection ::= sequence | bag | alternatives [5] sequence ::= '<rdf:Seq' idAttr? '>' collMember* '</rdf:Seq>' [6] bag ::= '<rdf:Bag' idAttr? '>' collMember* '</rdf:Bag> [7] alternatives ::= '<rdf:Alt' idAttr? '>' collMember+ '</rdf:Alt>' [8] collMember ::= hrefItem | valueItem [9] hrefItem ::= '<rdf:LI' hrefAttr '/>' [10] valueItem ::= '<rdf:LI>' value '</rdf:LI>' [11] idRefAttr ::= idAttr | hrefAttr [12] hrefAttr ::= 'rdf:HREF="' resourceURI '"' [13] idAttr ::= 'ID="' IDsymbol '"' [14] bagIdAttr ::= 'rdf:BAGID="' IDsymbol '"' [15] resourceURI ::= (see RFC1738) [16] IDsymbol ::= (any legal XML name symbol)The RDF element is a simple wrapper that marks the boundaries in an XML document where the content is explicitly intended to be mappable into an RDF data model instance.
Description contains the remaining elements that cause the creation of properties in the model instance. Each XML element E contained by a Description results in the creation of a property (a triple that is an element of the formal set Triples), where:
When HREF is specified with Description, the properties in the Description refer to the resource named in the HREF. A Description element without an HREF attribute creates an in-line resource. Typically such a resource will be a surrogate, or proxy, for some other real resource that does not have a recognizable URI. This in-line resource has a URI formed using the value of the ID attribute of the Description element, if present. When another Description or property value refers to the in-line resource it will use the value of the ID in an HREF attribute. When the other Description refers to the bag of nodes corresponding to the reified properties it will use the value of BAGID in an HREF attribute. Either ID or HREF may be specified on Description but not both together in the same element. The values for each ID and BAGID attribute must not appear more than once within a document nor may the same value be used in an ID and a BAGID; that is, these two attributes have XML AttType ID.
Seq, Bag, and Alt create an instance of a sequence, bag, or alternatives collection node type respectively. This node is the PropObj of an InstanceOf property pointing to the corresponding collection node type. The members of the collection are denoted by LI. Each XML element E contained by an LI corresponds to one member of the collection and results in the creation of a tuple where:
An RDF property takes the form:
[17] property ::= '<' propName idAttr? '>' value '</' propName '>' | '<' propName idRefAttr '/>' [18] propName ::= 'rdf:Value' | 'rdf:InstanceOf' | name | NSname ':' name [19] value ::= expression | string [20] name ::= (any legal XML name symbol) [21] NSname ::= (any legal XML namespace prefix) [22] string ::= (any XML text, with "<", ">", and "&" escaped)Within property, the resourceURI used in an HREF attribute identifies the resource that is the value of this property. The value of the ID attribute, if specified, is the identifier for the node that represents the reification of the property. If an expression is specified as a property value the value is the node given by the HREF of the Description or the (possibly implied) ID of the Description or collection. The propName Value may be used for expressing non-binary relations; see example 5.3. Strings must be well-formed XML; the usual XML content quoting and escaping mechanisms may be used if the string contains character sequences (e.g. "<" and "&") that violate the well-formedness rules or that otherwise might look like markup. The xml:lang attribute may be used as defined by [XML] to associate a language with the property value. When used, xml:lang adds no triples to the data model.
It is recommended that property names always be qualified with a namespace prefix to unambiguously connect the property definition with the corresponding RDF schema.
The abbreviated syntax replaces productions [3] and [17] of the grammar for the serialization syntax in the following manner:
[3a] description ::= '<rdf:Description' idRefAttr? bagIdAttr? propAttr* '/>' | '<rdf:Description' idRefAttr? bagIdAttr? propAttr* '>' property* '</rdf:Description>' | typedNode [17a] property ::= '<' propName idAttr? '>' value '</' propName '>' | '<' propName idRefAttr? bagIDAttr? propAttr* '/>' [23] typedNode ::= '<' typeName idRefAttr? bagIDAttr? propAttr* '/>' | '<' typeName idRefAttr? bagIDAttr? propAttr* '>' property* '</' typeName '>' [24] typeName ::= NSname ':' name [25] propAttr ::= propName '="' string '"' (with embedded quotes escaped)Each property type and value expressed in XML attribute form by productions [3a] and [25] is equivalent to the same property type and value expressed as XML content of the corresponding Description according to production [17]. Specifically; each XML attribute A specified with a Description start tag other than the attributes ID, HREF, or BAGID results in the creation of a property (a triple), where:
Property types and values expressed in XML attribute form by productions [17a] and [25] are equivalent to the same property types and values expressed as XML content of a single Description element D and the resource refered to by D is the value of the property named by the XML element according to productions [19], [2], and [3]. Specifically; each property start tag containing attribute specifications other than ID, HREF, or BAGID results in the creation of a node R where R is the Value of the property. If HREF is specified, R is the node corresponding to the resource whose URI is the value of the attribute, else if ID is specified R is a new node whose identifier is the value of the attribute, otherwise R is anonymous. Each XML attribute A except ID, HREF, and BAGID specified with that same property start tag results in the creation of a property (a triple), where:
Descriptions may be signed to facilitate decisions that require trust. Simple signatures include checksums or other Descriptions about independently verifiable characteristics of a resource. The simplest example of a signature is a statement that the associated Description applies only to the version of the resource labeled with a given creation date. Stronger signatures will include cryptographic measures to increase the likelihood of detection of falsification of or inadvertent changes to the signed Description or the resource(s) to which it applies.
D(We use a notation where nodes are represented as ellipses, arcs as arrows, and atomic values i.e. strings are given in rectangles.)
This small graph can be exchanged in the serialization syntax as:
In most of the example figures the Bag corresponding to the reified properties in each Description will be omitted from the graph to improve readability. To illustrate the complete graph, consider the following example:<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author>John Smith</BIB:Author> </RDF:Description> </RDF:RDF>
<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc" RDF:BAGID="D_001"> <BIB:Author>John Smith</BIB:Author> <BIB:Title>How to install IXI 3.4</BIB:Title> </RDF:Description> </RDF:RDF>As shown in Figure 2, the Description itself becomes a Bag node where the contents of the collection list the individual properties that were part of that particular Description.
DNote that the Description uses the HREF attribute to say that the properties refer to the existing node whose URI is "http://www.bar.com/some.doc".
We could create a more elaborate model in order to say additional things about John Smith, such as his contact information. We might construct the model:
Dwhich could be exchanged using the RDF serialization representation:
Note here that the Description that is the value of the Author property does not have an HREF attribute. Therefore, this Description creates a new (unnamed) node and this new node is the property value of the Author property.<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author> <RDF:Description> <BIB:Name>John Smith</BIB:Name> <BIB:Email>john@smith.com</BIB:Email> <BIB:Phone>+1 (555) 123-4567</BIB:Phone> </RDF:Description> </BIB:Author> </RDF:Description> </RDF:RDF>
The serialization above provides the same properties as this second serialization, with an ID specified for the anonymous resource:
As an example of making a statement about a statement, consider the case of wanting to indicate when a particular description was written and who wrote the description.<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author RDF:HREF="#John_Smith"/> </RDF:Description> <RDF:Description ID="John_Smith"> <BIB:Name>John Smith</BIB:Name> <BIB:Email>john@smith.com</BIB:Email> <BIB:Phone>+1 (555) 123-4567</BIB:Phone> </RDF:Description> </RDF:RDF>
DWhat we want to say in the model is expressed by this pair of graphs; that we have an XML encoding of some description, and that there is some other XML content that makes further statements about that encoding. If we look into the details, the graph is really as shown in Figure 5.
DThis model would be expressed as:
Observe that the CreatedOn and CreatedBy properties refer not to "http://www.bar.com/some.doc" but rather to the statement "John Smith is the creator of http://www.bar.com/some.doc". That statement was, according to this graph, made by Jane Cooper.<?xml:namespace name="http://purl.org/metadata/dublin_core#" as="DC"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://www.w3.org/Schemas/DS-Schema#" as="DS"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc" RDF:BAGID="Statement_001"> <DC:Creator>John Smith</DC:Creator> </RDF:Description><RDF:Description RDF:HREF="#Statement_001"> <DS:CreatedOn>1998-02-06T14:00Z</DS:CreatedOn> <DS:CreatedBy>Jane Cooper</DS:CreatedBy> </RDF:Description> </RDF:RDF>
Also note that node labels such as "RDF:Property" are shorthand for a full URI such as "http://www.w3.org/TR/WD-rdf-syntax#Property".
Figure 5a omits the Bag corresponding to the second Description element; that Bag is shown in Figure 5b
D
DThis model could be exchanged as:
To further illustrate aggregates, consider an example of a document with two authors specified alphabetically, a title specified in two different languages, and having two equivalent locations on the Web:<?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Seq ID="JSPapersByDate"> <RDF:LI RDF:HREF="http://www.dogworld.com/Aug96.doc"/> <RDF:LI RDF:HREF="http://www.webnuts.net/Jan97.html"/> <RDF:LI RDF:HREF="http://www.carchat.com/Sept97.html"/> </RDF:Seq> <RDF:Seq ID="JSPapersBySubj"> <RDF:LI RDF:HREF="http://www.carchat.com/Sept97.html"/> <RDF:LI RDF:HREF="http://www.dogworld.com/Aug96./doc"/> <RDF:LI RDF:HREF="http://www.webnuts.net/Jan97.html"/> </RDF:Seq> </RDF:RDF>
<?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://purl.org/metadata/dublin_core#" as="DC"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.foo.com/cool.html"> <DC:Creator> <RDF:Seq ID="CreatorsAlphabeticalBySurname"> <RDF:LI>Mary Andrew</RDF:LI> <RDF:LI>Jacky Crystal</RDF:LI> </RDF:Seq> </DC:Creator> <DC:Identifier> <RDF:Bag ID="MirroredSites"> <RDF:LI RDF:HREF="http://www.foo.com.au/cool.html"/> <RDF:LI RDF:HREF="http://www.foo.com.it/cool.html"/> </RDF:bag> </DC:Identifier> <DC:Title> <RDF:Alt> <RDF:LI xml:lang="en">The Coolest Web Page</RDF:LI> <RDF:LI xml:lang="it">Il Pagio di Web Fuba</RDF:LI> </RDF:Alt> </DC:Title> </RDF:Description> </RDF:RDF>
Dwhich could be exchanged as:
A common use of this higher-arity capability is when dealing with units of measure. A person's weight is not just a number like 94, it also requires us to specify the unit of measure used. In this case we might be using either pounds or kilograms. We could use a relationship with an additional arc to record the fact that John Smith is a rather strapping gentleman:<?xml:namespace name="http://purl.org/metadata/dublin_core#" as="DC"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://mycorp.com/schemas/my-schema#" as="LOCAL"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.webnuts.net/Jan97.html"> <DC:Subject> <RDF:Description ID="subject_001"> <LOCAL:Classification>Dewey Decimal Code</LOCAL:Classification> <RDF:Value>020 - Library Science</RDF:Value> </RDF:Description> </DC:Subject> </RDF:Description> </RDF:RDF>
Dwhich can be exchanged as:
assuming the node "pounds" was defined in a NIST schema with the URI http://www.nist.gov/units/pounds.<?xml:namespace name="http://www.nist.gov/RDFschema/" as="NIST"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="John_Smith"> <NIST:Weight> <RDF:Description ID="weight_001"> <NIST:Units RDF:HREF="http://www.nist.gov/units/pounds"/> <RDF:Value>200</RDF:Value> </RDF:Description> </NIST:Weight> </RDF:Description> </RDF:RDF>
may be abbreviated as<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author>John Smith</BIB:Author> </RDF:Description> </RDF:RDF>
This abbreviation is especially useful when embedding RDF in HTML documents; the text "John Smith" in the unabbreviated form will be rendered by conforming HTML 4.0 and earlier formatters while nothing would be rendered in the abbreviated form.<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc" BIB:Author="John Smith" /> </RDF:RDF>
The expression
<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author> <RDF:Description> <BIB:Name>John Smith</BIB:Name> <BIB:Email>john@smith.com</BIB:Email> <BIB:Phone>+1 (555) 123-4567</BIB:Phone> </RDF:Description> </BIB:Author> </RDF:Description> </RDF:RDF>may be abbreviated as
<?xml:namespace name="http://docs.r.us.com/bibliography-info/" as="BIB"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.bar.com/some.doc"> <BIB:Author BIB:Name="John Smith" BIB:Email="john@smith.com" BIB:Phone="+1 (555) 123-4567" /> </RDF:Description> </RDF:RDF>The expression
<?xml:namespace name="http://purl.org/metadata/dublin_core#" as="DC"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://mycorp.com/schemas/my-schema#" as="LOCAL"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.webnuts.net/Jan97.html"> <DC:Subject> <RDF:Description ID="subject_001"> <LOCAL:Classification>Dewey Decimal Code</LOCAL:Classification> <RDF:Value>020 - Library Science</RDF:Value> </RDF:Description> </DC:Subject> </RDF:Description> </RDF:RDF>may be abbreviated as
<?xml:namespace name="http://purl.org/metadata/dublin_core#" as="DC"?> <?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://mycorp.com/schemas/my-schema#" as="LOCAL"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.webnuts.net/Jan97.html"> <DC:Subject ID="subject_001" LOCAL:Classification="Dewey Decimal Code" RDF:Value="020 - Library Science" /> </RDF:Description> </RDF:RDF>The expression
<?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://mycorp.com/my-schema#" as="LOCAL"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.webnuts.net/"> <LOCAL:Abstract> <RDF:Description> <RDF:InstanceOf href="http://mycorp.com/my-schema#Sitemap"/> <LOCAL:Title>Map of our Site</LOCAL:Title> <LOCAL:ValidUntil>1999-02-01T00:00Z</LOCAL:ValidUntil> </RDF:Description> </LOCAL:Abstract> </RDF:Description> </RDF:RDF>may be abbreviated as
<?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://mycorp.com/my-schema#" as="LOCAL"?> <RDF:RDF> <RDF:Description RDF:HREF="http://www.webnuts.net/"> <LOCAL:Abstract> <LOCAL:Sitemap LOCAL:Title="Map of our Site" LOCAL:ValidUntil="1999-02-01T00:00Z" /> </LOCAL:Abstract> </RDF:Description> </RDF:RDF>
The members of the Working Group who helped design this specfication, debate proposals, provide words, proofread numerous drafts and ultimately reach consensus are: Renato Iannella (DSTC), Tsuyoshi SAKATA (DVL), Murray Maloney (Grif), Bob Schloss (IBM), Naohiko URAMOTO (IBM), Bill Roberts (KnowledgeCite), Ron Daniel (LANL), Arthur van Hoff (Marimba), Andrew Layman (Microsoft), Chris McConnell (Microsoft), Jean Paoli (Microsoft), R.V. Guha (Netscape), Ora Lassila (Nokia), Ralph LeVan (OCLC), Eric Miller (OCLC), Charles Wicksteed (Reuters), Misha Wolf (Reuters), Wei Song (SISU), Lauren Wood (SoftQuad), Tim Bray (Textuality), Paul Resnick (University of Michigan), Tim Berners-Lee (W3C), Dan Connolly (W3C), Jim Miller (W3C), Ralph Swick (W3C).
This document is the collective work of all of the above. The editors are indebted to each of them for helping to create this document.
The XML Working Group is currently developing a facility that will allow (at least) Generic Identifiers (tag names) to have a prefix which will make them unique and will prevent name clashes when developing documents that mix elements from different schemas. This facility allows a document's prolog to contain a set of Processing Instructions (PIs) of the form:
<?xml:namespace name="some-uri" as="some-abbreviation"?>for example
<?xml:namespace name="http://www.w3.org/TR/WD-rdf-syntax#" as="RDF"?> <?xml:namespace name="http://www.purl.org/metadata/dublin_core#" as="DC"?>Elements in the document may then use generic identifiers of the form <RDF:Description> or <DC:Title>. Those element names would expand to URIs such as http://www.w3.org/TR/WD-rdf-syntax#Description.
Authors concerned about very old browsers may place all RDF expressions at the end of the document head.
Authors concerned about preventing their RDF content from rendering in old browsers may use the abbreviated syntax to move the property value into an attribute. Not all properties can be expressed this way.
<link rel="meta" href="mydocMetadata">
[[This section to be completed.]]
[[This section to be completed.]]
Scheme is a term used in the Dublin Core community to denote the specific controlled vocabulary from which a Value has been chosen. Examples of vocabularies covered by schemes include units of measure, library subject heading codes, and Dewey Decimal numbers. This same facility might also be used to denote a particular encoding format; e.g. date in ISO 8601 form, or name in "family, given" form. We recognize that this mechanism will be common to many RDF applications and it seems appropriate to indicate a recommended practice in the core specification.
Should RDF specify the method for determining a namespace when a namespace qualifier is omitted?
The XML namespace proposal does not specify how the namespace URI is to be combined with a qualified element name to produce a URI for the element description. RDF would like to be able to compute a URI to access the RDF Schema definition of a particular property type.
A property value may need to be a string tagged in multiple languages; how do we accomplish this?
Revision History:
16-February-1998: Editorial cleanup, prep for second
public distribution
6-February-1998: Editorial cleanup, add and revise some
examples
11-January-1998: Renaming and collapsing of several elements
14-November-1997: Further refinement, especially regarding
assertions
3-November-1997: Edits in preparation for second public
distribution
2-October-1997: First public draft
1-October-1997: Edits in preparation for first public
distribution
1-August-1997: First draft to Working Group
Last updated: 1998-02-19T02:49:22Z
Last saved: $Date: 1998/02/19 02:50:18 $