Copyright © 2007 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
The purpose of the Protocol for Web Description Resources (POWDER) is to provide a means for individuals or organizations to describe a group of resources through the publication of machine-readable metadata, as motivated by the POWDER Use Cases [USECASES]. This document details the creation and lifecycle of Description Resources (DRs), which encapsulate such metadata. These are typically represented in a highly constrained XML dialect that is relatively human-readable. The meaning of such DRs are underpinned by formal semantics, accessible by performing a GRDDL Transform.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is a Public Working Draft, designed to aid discussion and solicit feedback. Changes since earlier versions of this document are recorded in the change log. Please note that the Working Group expects to make few changes to this draft before making its Last Call announcement at the end of this month (July 2008). It includes a feature at risk related to the status of the HTTP Link header.
This document was developed by the POWDER Working Group which expects to advance this Working Draft to Recommendation Status.
Please send comments about this document to public-powderwg@w3.org (with public archive).
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
link
ElementsThe Protocol for Web Description Resources (POWDER) facilitates the publication of descriptions of multiple resources such as all those available from a Web site. These descriptions are always attributed to a named individual, organization or entity that may or may not be the creator of the described resources. This contrasts with more usual metadata that typically applies to a single resource, such as a specific document's title, which is usually provided by its author.
This document sets out how Description Resources (DRs) can be created and published, how to link to DRs from other online resources, and, crucially, how DRs may be authenticated and trusted. The aim is to provide a platform through which opinions, claims and assertions about online resources can be expressed by people and exchanged by machines. POWDER has evolved from the data model developed for the final report [XGR] of the Web Content Label Incubator Group [WCL-XG] from which we define a Description Resource as: "a resource that contains a description, a definition of the scope of the description and assertions about both the circumstances of its own creation and the entity that created it."
The next section introduces the division between the operational semantics of POWDER (designed to be easy and practical to use in every day situations) and the more formal semantics (designed to make POWDER available on the broader Semantic Web). This division means that there are several components to the Protocol for Web Description Resources which in turn leads to there being several documents in the set.
The method of defining the scope of a DR, that is, defining what is being described, is provided in Grouping of Resources [GROUP]. The layered semantics of POWDER is defined in a Formal Semantics document [FORMAL]. It is hoped that the provision of those documents allows the present one to present a clearer, more concise definition of the structure and use of Description Resources. The full set of POWDER documents also includes its Use Cases, Primer and Test Suite, together with the namespace documents [WDR, WDRS, WDRD] and GRDDL transform [PDR-GRDDL].
POWDER takes a very broad approach so that it is possible for both the resource creator and third parties to make assertions about all kinds of things, with no architectural limits on what they are making claims about. For example, medically proficient organizations might be concerned with properties of the agencies and processes that produce Web content (e.g. companies, people, and their credentials). Equally, a 'Mobile Web' application might need to determine the properties of various devices such as their screen dimensions, and those device types might be described with such properties by their manufacturer or by others. Although the broad approach is supported, we have focused on Web resources rather than trying to define a universal labeling system for objects. In practice, POWDER associates a description with one or more IRIs [IRI] that must then be interpreted as being descriptions of the resources resolved from those IRIs.
Trust is a central theme of POWDER, however, we do not prescribe a single method through which trust must be conferred on Description Resources. By its very nature, trust is a human judgment that can only be made by weighing the likelihood that the data is true against the consequences of it being false. This judgment is highly dependant on the circumstances under which the need to extend trust arises. POWDER does, however, provide support for, and is amenable to, a variety of methods through which users and user agents can establish trust.
Reference is made throughout the document to a POWDER processor, i.e. software that can process POWDER documents. The minimum specification for such a piece of software, and suggested additional features, is set out in Section 3.
The Protocol for Web Description Resources has been designed with a variety of content production workflows in mind. It offers a practical contribution to such areas as content discovery, personalization and access control; one that can be implemented readily by non-specialists. There is, however, a tension between this operational approach and the broader goal of making the data available in a format that can be processed on the Semantic Web. By making data from potentially disparate sources interoperable, and by enabling machines to process the meaning of that data, the Semantic Web offers exciting possibilities in precisely the areas of interest to POWDER.
The tension between what can be processed by humans and what can be processed by machines is resolved by defining both operational and formal semantics of Description Resources, and by bridging much of the gap between the two by way of a GRDDL transform that is associated with the root POWDER namespace. POWDER documents are written in a highly constrained dialect of XML that may also include RDF/XML constructs within some elements. Such documents may be processed directly in specialized systems, however, for more general environments, it is appropriate to perform the GRDDL transform to render the data as syntactically valid RDF/OWL (see Section 2.2 below). The semantics of such documents, known as POWDER-S documents, are defined in a companion Formal Semantics document [FORMAL]. This includes a Semantic Extension to RDF that must be understood if the OWL data is to be processed effectively.
The POWDER vocabulary namespace is http://www.w3.org/2007/05/powder#
for which we use the prefix wdr
.
The POWDER-S namespace is http://www.w3.org/2007/05/powder-s#
for which we use the prefix wdrs
.
All prefixes used in this document, together with their associated namespaces, are shown in the table below.
Prefix | Namespace |
---|---|
wdr | http://www.w3.org/2007/05/powder# |
wdrs | http://www.w3.org/2007/05/powder-s# |
rdf | http://www.w3.org/1999/02/22-rdf-syntax-ns# |
rdfs | http://www.w3.org/2000/01/rdf-schema#" |
owl | http://www.w3.org/2002/07/owl# |
foaf | http://xmlns.com/foaf/0.1/ |
dc | http://purl.org/dc/elements/1.1/ |
dcterms | http://purl.org/dc/terms/ |
xsd | http://www.w3.org/TR/xmlschema-2/ |
In this document, the words MUST, MUST NOT, SHOULD, SHOULD NOT and MAY are to be interpreted as described in RFC2119.
White space is any of U+0009, U+000A, U+000D and U+0020. A space-separated list is a string of which the items are separated by one or more space characters (in any order). The string may also be prefixed or suffixed with zero or more of those characters. To obtain the values from a space-separated list user agents MUST replace any sequence of space characters with a single U+0020 character, dropping any leading or trailing U+0020 character, and then chopping the resulting string at each occurrence of a U+0020 character, dropping that character in the process.
The (unqualified) terms POWDER, POWDER Document and Description Resource (DR) refer to operational representations that are encoded largely in XML. The terms POWDER-S and DR-S refer to RDF/OWL representations, the full semantics of which are expressed when account is taken of the extension defined in the Formal Semantics document [FORMAL].
The following natural language statement:
On 14th December 2007, the entity described at authority.example.org said that everything on example.com is red and square.
is encoded in POWDER as shown in the example below which in turn is followed by explanatory notes.
Example 2-1: Generic Example of a POWDER Document Containing a Single Description Resource [XML]
<?xml version="1.0"?> 1 <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> 2 <attribution> 3 <maker src="http://authority.example.org/foaf.rdf#me" /> 4 <issued>2007-12-14T00:00:00</issued> 5 </attribution> 6 <dr> 7 <iriset> 8 <includehosts>example.com</includehosts> 9 </iriset> 10 <descriptorset> 11 <ex:color>red</ex:color> 12 <ex:shape>square</ex:shape> 13 <displaytext>Everything on example.com is red and square</displaytext> 14 <displayicon src="http://authority.example.org/icon.png"< /> 15 </descriptorset> 16 </dr> 17 </powder>
Explanation:
powder
. The ex
namespace is used to exemplify a descriptive vocabulary and is fictitious.attribution
element. This contains the information about who has provided the description,
and typically will also include information about when it was created and any validity period.maker
element MUST be included. This is interpreted by the POWDER
GRDDL Transform as the following triple:
<> foaf:maker http://authority.example.org/foaf.rdf#me
.
Since the range of foaf:maker
is foaf:Agent
, it follows that an IRI referenced in the maker element
MUST resolve to an RDF class (or sub class) of that type (which describes a person or an organization). Alternatively, a POWDER
document MAY include the foaf:Agent
class directly as RDF/XML as shown in Example 2-2 below.
The issued
element within the attribution element (line 4) is optional and
maps to dcterms:issued
.
The validfrom
and validuntil
elements discussed in Section 5.2 may be included in the attribution element,
as can arbitrary RDF properties that describe the POWDER document. However, these MUST have values that are either literal or
are resources identified by a URIref (using the rdf:resource="URIref"
construct).
dr
).iriset
element and, as described in the Grouping document, this MUST NOT be empty and MUST NOT
contain any elements from any other namespace. If more than one iriset
element is included then the scope of
the DR is the union of the resources identified by the IRIs in all sets.descriptorset
element
(and/or tagset
see section 2.7) that MUST NOT be empty and MAY contain
RDF/XML that describes the IRIs in the IRI set. Since the subject of the triples is not explicit and is
only accessed through processing, there are some limitations on the RDF that can be included, namely that child
elements of the descriptorset
MUST be one of the following:
The Formal Semantics document [FORMAL] provides full details of these constraints and gives examples.
The key limitation is that a descriptorset
MUST NOT contain any blank nodes.
As shown in lines 13 and 14, a textual and/or graphic summary that can be displayed to end users may be
included using displaytext
and
displayicon
respectively. The GRDDL transform maps these to
dc:description
and foaf:depiction
respectively.
Operationally, a user (or user agent) should begin the examination of a POWDER document by considering the attribution element which, if
the document is valid in the XML-sense of the term, will be present
and contain a maker
element.
This element is mandatory as, for most people, deciding whether to trust a given description is typically most dependent on answering the question
"who says?" If the IRI that is the value of the src
attribute of the maker element points to a
description of a trusted individual or entity (or incluides such a description directly), the data provided in the remainder of
the document will usually be trusted, subject to integrity-checking mechanisms such as those discussed in section 5.
If the user (or user agent) confers his/her trust in the document, then the remainder of the data can be processed, either in an entirely operational manner or by performing the GRDDL transform associated with the POWDER namespace and merging the resulting RDF graph (see section 2.2 below).
Either way, example 2-1 means that the processor can be confident that any resource identified by an IRI with a host having 'example.com' as its last two components will be red and square. Conversely, an agent seeking resources that are red and square will trust example.com to provide them.
User agents MAY display the text and/or icon to end users in any way deemed appropriate.
A POWDER document may contain any number of DRs, each describing its own IRI set(s), each of which will be attributed to the same person or entity. Where those IRI sets overlap, the descriptions are additive. In Example 2-2 below, the opinion of the Exemplary Description Authority is that everything on example.com is red; IRIs on example.com where the path starts with /foo can be dereferenced to resources that are BOTH red AND square.
Example 2-2: Generic Example of a POWDER Document Containing Multiple Description Resources [XML]
<?xml version="1.0"?> 1 <powder xmlns="http://www.w3.org/2007/05/powder#" 2 xmlns:foaf="http://xmlns.com/foaf/0.1/" 3 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 4 xmlns:ex="http://example.org/vocab#"> 5 <attribution> 6 <maker> 7 <foaf:Organization> 8 <foaf:homepage rdf:resource="http://authority.example.org/" /> 9 <foaf:name>The Exemplary Description Authority</foaf:name> 10 <foaf:nick>EDA</foaf:nick> 11 </foaf:Organization> 12 </maker> 13 </attribution> 14 <dr> 15 <iriset> 16 <includehosts>example.com</includehosts> 17 </iriset> 18 <descriptorset> 19 <ex:color>red</ex:color> 20 </descriptorset> 21 </dr> 22 <dr> 23 <iriset> 24 <includehosts>example.com</includehosts> 25 <includepathstartswith>/foo</includepathstartswith> 26 </iriset> 27 <descriptorset> 28 <ex:shape rdf:resource="http://example.org/vocab#square" /> 29 </descriptorset> 30 </dr> 31 </powder>
It is possible to create sets of Description Resources that are exclusive, i.e. where only one of a given list applies, as detailed in Section 2.3. Other variations on the basic POWDER model set out in the preceding examples are discussed in later sections of this document.
The operational semantics of POWDER, as defined above, are underpinned by more formal semantics. A GRDDL Transformation (which uses XSLT) is associated with the POWDER namespace. When the transformation is performed on a POWDER document, a Semantic POWDER document (POWDER-S) is its output. The attribution information in the source document is encoded as a description of the POWDER-S document, and both the IRI set and descriptor set are represented as OWL classes. A sub class relationship is then asserted between the two from which it can be deduced that all instances of the IRI set are also instances of the descriptor set.
The aim of POWDER-S is to make POWDER data available to more general Semantic Web tools, not to create an alternative encoding. All POWDER-S documents are syntactically valid RDF/OWL documents, however, logical inferences may only be drawn by applications that implement the semantic extension defined in the Formal Semantics document [FORMAL]. That document provides full details of the transformation which is split into two steps. In brief: the first step reformulates the IRI set definition purely in terms of regular expressions that are matched against a candidate IRI. Other elements of the document are unaffected in this internemdiate stage which is known as POWDER-BASE. The second step transforms POWDER-BASE into POWDER-S. This document is not concerned with the intermediate step and presents only POWDER and POWDER-S examples.
Example 2-3: Generic example of a POWDER-S Document Containing a Single Description Resource [RDF/XML]
This is the result of the GRDDL transform performed on example 2-1
1 <?xml version="1.0"?> 2 <rdf:RDF 3 xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" 4 xmlns:foaf="http://xmlns.com/foaf/0.1/" 5 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 6 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" 7 xmlns:owl="http://www.w3.org/2002/07/owl#" 8 xmlns:dc="http://purl.org/dc/elements/1.1/" 9 xmlns:dcterms="http://purl.org/dc/terms/0.1/" 10 xmlns:ex="http://example.org/vocab#"> 11 12 <rdf:Description rdf:about=""> 13 <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> 14 <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> 15 </rdf:Description> 16 17 <owl:Class rdf:nodeID="iriset_1"> 18 <owl:intersectionOf rdf:parseType="Collection"> 19 <owl:Restriction> 20 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 21 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> 22 </owl:Restriction> 23 </owl:intersectionOf> 24 </owl:Class> 25 26 <owl:Class rdf:nodeID="descriptorset_1"> 27 <owl:intersectionOf rdf:parseType="Collection"> 28 <owl:Restriction> 29 <owl:onProperty rdf:resource="http://example.org/vocab#color" /> 30 <owl:hasValue>red</owl:hasValue> 31 </owl:Restriction> 32 <owl:Restriction> 33 <owl:onProperty rdf:resource="http://example.org/vocab#shape" /> 34 <owl:hasValue>square</owl:hasValue> 35 </owl:Restriction> 36 </owl:intersectionOf> 37 <dc:description>Everything on example.org is red and square</dc:description> 38 <foaf:depiction rdf:resource="http://example.org/icon.png" /> 39 </owl:Class> 40 41 <owl:Class rdf:about="#iriset_1"> 42 <rdfs:subClassOf rdf:resource="#descriptorset_1"/> 43 </owl:Class> 44 45 </rdf:RDF>
It is anticipated that POWDER-S documents will typically be generated by performing the GRDDL transform associated with POWDER after validity and trust has been conferred on the input document. However, a POWDER-S document may be created independently in which case the question of trust remains open.
If trust is conferred on a POWDER-S document directly, or is inherited from the POWDER document that was transformed to generate it, then the graph can be merged with other graphs available to the processor.
The matchesregex
property restriction in the IRI set class (lines 17 - 24)
draws on a semantic extension defined in the Formal Semantics
document [FORMAL]. This supports the critical matching of an IRI against a regular expression to confer class membership on that IRI.
For emphasis we repeat that if the POWDER semantic extension is not understood, a generic RDF/OWL tool will not be
able to ascribe any meaning to the properties of the IRI set class.
Notice that an rdf:nodeID
is used to identify the IRI set and descriptor set classes meaning that they cannot be referenced by external documents.
This is deliberate and ensures that further properties cannot be added that might render the assertions made the POWDER document author incorrect.
The descriptor set class is pure RDF/OWL and is effectively a re-expression of the descriptorset
element in a POWDER document with
full semantics. Lines 26 - 39 of example 2-3 are derived directly from example 2-1 lines 10 - 15.
As noted in Section 2.1, a POWDER document may contain any number of DRs. These may offer overlapping descriptions of the same resources. It is often the case though that a description of one set of resources must not be applied to other resources on the same Web site.
A modified version of example 2-2 is shown below as example 2-4. Note that the property in line 19, part of the second DR, is now the same as that in line 10 which is part of the first DR — but with a different value. Taken together, the two DRs state that in the opinion of the person or entity described at http://authority.example.org/foaf.rdf#me, all resources on example.com are red, but that those on example.com where the path starts with /foo are BOTH red AND blue.
Example 2-4: A POWDER Document Containing Conflicting Description Resources [XML]
<?xml version="1.0"?> 1 <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> 2 <attribution> 3 <maker src="http://authority.example.org/foaf.rdf#me" /> 4 </attribution> 5 <dr> 6 <iriset> 7 <includehosts>example.com</includehosts> 8 </iriset> 9 <descriptorset> 10 <ex:color>red</ex:color> 11 </descriptorset> 12 </dr> 13 <dr> 14 <iriset> 15 <includehosts>example.com</includehosts> 16 <includepathstartswith>/foo</includepathstartswith> 17 </iriset> 18 <descriptorset> 19 <ex:color>blue</ex:color> 20 </descriptorset> 21 </dr> 21 </powder>
One way to avoid this paradox would be to add an extra definition to the first IRI set that excluded IRIs beginning with /foo as shown in example 2-5 thus creating two DRs with scopes that are disjoint.
Example 2-5: A POWDER Document Containing Disjoint Description Resources [XML]
<?xml version="1.0"?> 1 <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> 2 <attribution> 3 <maker src="http://authority.example.org/foaf.rdf#me" /> 4 </attribution> 5 <dr> 6 <iriset> 7 <includehosts>example.com</includehosts> 8 <excludepathstartswith>/foo</excludepathstartswith> 9 </iriset> 10 <descriptorset> 11 <ex:color>red</ex:color> 12 </descriptorset> 13 </dr> 14 <dr> 15 <iriset> 16 <includehosts>example.com</includehosts> 17 <includepathstartswith>/foo</includepathstartswith> 18 </iriset> 19 <descriptorset> 20 <ex:color>blue</ex:color> 21 </descriptorset> 22 </dr> 23 </powder>
POWDER supports this structure, however, in a commercial content production environment it can be impractical to keep track of which exclusions should be written into which IRI sets, even with the aid of tools. This is particularly so where content is being produced in multiple departments or bought in from multiple suppliers. In such situations, the more typical need, and the more natural way of working, is to create a description that applies to all content on a given Web site except where indicated.
For this reason, POWDER uses the concept of an ordered list to create a set of DRs, only one of which applies to a given IRI.
Example 2-6: A POWDER Document Containing an Ordered List of Description Resources [XML]
<?xml version="1.0"?> 1 <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> 2 <attribution> 3 <maker src="http://authority.example.org/foaf.rdf#me" /> 4 <issued>2007-12-14T00:00:00</issued> 5 <abouthosts>example.com</abouthosts> 6 </attribution> 7 <ol> 8 <dr> 9 <iriset> 10 <includehosts>example.com</includehosts> 11 <includepathstartswith>/foo</includepathstartswith> 12 </iriset> 13 <descriptorset> 14 <ex:color>blue</ex:color> 15 </descriptorset> 16 </dr> 17 <dr> 18 <iriset> 19 <includehosts>example.com</includehosts> 20 </iriset> 21 <descriptorset> 22 <ex:color>red</ex:color> 23 </descriptorset> 24 </dr> 25 </ol> 26 </powder>
In the POWDER namespace, the ol
tag indicates an ordered list of Description Resources. If a given IRI is within the scope of the
first DR in the list, then that DR applies, if not, move on to the second DR and see if the given IRI is within its scope and so on
until either a match is made or the end of the list is reached. As such, it is important to place any exclusions before other DRs that include that
resource in their scope, or else the exclusion will never be matched. An IRI can only be described by 0 or 1 DRs from an ordered list.
The first DR in the list in example 2-6 covers resources on example.com with a path starting with /foo and describes them as being blue.
Any resource available from example.com that does not have a path starting with /foo is described as being red. Further DRs may be added to
the list without the need to edit either of the existing DRs, although order may be important. This would be the case, if, for instance,
resources available from example.com with a path starting with /foo and a query string containing material=natural
were green. Such a DR
would need to go above the first one in the example.
It is noteworthy that if the content provider at example.com wishes to link to this document, he/she can arrange for all resources to include exactly the same pointer — the POWDER document contains all the necessary information to discover how the red and blue resources are arranged. Linkage is discussed in more detail in section 4. Moreover, the disposition of content with different characteristic across a given Web site or set of Web sites can be discovered by processing the one document. If processed alongside a site map, for example, this becomes a powerful content discovery mechanism.
In order to minimize the processing of a sequence of DRs like this, we introduce the
abouthosts
element in line 5.
This takes a white space separated list of hosts and can be included in the attribution element of any POWDER document, whether it
contains an ordered list of DRs or not. In this context, abouthosts
provides a processing hint, quickly identifying
whether a candidate resource might be described by the DRs in the document. The element also has a bigger role to play
which is discussed in section 2.5; for now we note that if the host component of a given IRI is included in the list
given as the value for the abouthosts
element, then the POWDER document may, but is not guaranteed to, contain a
description of that IRI. If the host component of a given IRI is not included in the list given as the value for
the abouthosts
element, then the processor MUST assume that the POWDER document does not contain a description of that IRI.
From a discovery point of view, it provides an efficient method of hinting at where to find the resources that match the given description(s).
POWDER-S does not support ordered lists or abouthosts
and each DR is self contained. The assertion of the
sub class relationship is made in such a way as to create the necessary exclusions as shown in example 2-7 below.
Example 2-7: The POWDER-S Document Derived From Example 2-6 [RDF/XML]
1 <?xml version="1.0"?> 2 <rdf:RDF 3 xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" 4 xmlns:foaf="http://xmlns.com/foaf/0.1/" 5 xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 6 xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" 7 xmlns:owl="http://www.w3.org/2002/07/owl#" 8 xmlns:dc="http://purl.org/dc/elements/1.1/" 9 xmlns:dcterms="http://purl.org/dc/terms/0.1/" 10 xmlns:ex="http://example.org/vocab#"> 11 12 <rdf:Description rdf:about=""> 13 <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> 14 <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> 15 </rdf:Description> 16 17 <owl:Class rdf:nodeID="aboutset"> <!-- from the abouthosts element --> 18 <owl:intersectionOf rdf:parseType="Collection"> 19 <owl:Restriction> 20 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 21 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string"> 22 \:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(\:([0-9]+))?\/ 23 </owl:hasValue> 24 </owl:Restriction> 25 </owl:intersectionOf> 26 </owl:Class> 27 28 <owl:Class rdf:nodeID="iriset_1"> 29 <owl:intersectionOf rdf:parseType="Collection"> 30 <owl:Restriction> 31 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 32 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> 33 </owl:Restriction> 34 <owl:Restriction> 35 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 36 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]*)(\:([0-9]+))?\/foo</owl:hasValue> 37 </owl:Restriction> 38 </owl:intersectionOf> 39 </owl:Class> 40 41 <owl:Class rdf:nodeID="descriptorset_1"> 42 <owl:intersectionOf rdf:parseType="Collection"> 43 <owl:Class rdf:about="#aboutset" /> 44 <owl:Restriction> 45 <owl:onProperty rdf:resource="http://example.org/vocab#color" /> 46 <owl:hasValue>blue</owl:hasValue> 47 </owl:Restriction> 48 </owl:intersectionOf> 49 </owl:Class> 50 51 <owl:Class rdf:about="#iriset_1"> 52 <rdfs:subClassOf rdf:resource="#description_1"/> 53 </owl:Class> 54 55 <owl:Class rdf:nodeID="iriset_2"> 56 <owl:intersectionOf rdf:parseType="Collection"> 57 <owl:Restriction> 58 <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> 59 <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> 60 </owl:Restriction> 61 </owl:intersectionOf> 62 </owl:Class> 63 64 <owl:Class rdf:nodeID="descriptorset_2"> 65 <owl:intersectionOf rdf:parseType="Collection"> 66 <owl:Class rdf:about="#aboutset" /> 67 <owl:Restriction> 68 <owl:onProperty rdf:resource="http://example.org/vocab#color" /> 69 <owl:hasValue>red</owl:hasValue> 70 </owl:Restriction> 71 </owl:intersectionOf> 72 </owl:Class> 73 74 <owl:Class> 75 <owl:intersectionOf rdf:parseType="Collection"> 76 <owl:Class rdf:about="#iriset_2"/> 77 <owl:Class> 78 <owl:complementOf rdf:parseType="Collection"> 79 <owl:Class rdf:about="#iriset_1"/> 80 </owl:complementOf> 81 </owl:Class> 82 </owl:intersectionOf> 83 <rdfs:subClassOf rdf:resource="#description_2"/> 84 </owl:Class> 85 86 </rdf:RDF>
The key feature of example 2-7 is in lines 74 - 84 where the sub class relationship between iriset_2
and descriptorset_2
is asserted. This uses owl:complementOf
to exclude iriset_1
(i.e.
everything on example.com with a path starting with /foo). If a third DR were added to the ordered list in example 2-6,
then both iriset_1
and iriset_2
would be excluded from its sub class relationship in its POWDER-S version thus:
<owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#iriset_3"/> <owl:Class> <owl:complementOf rdf:parseType="Collection"> <owl:Class rdf:about="#iriset_2"/> <owl:Class rdf:about="#iriset_1"/> </owl:complementOf> </owl:Class> </owl:intersectionOf> <rdfs:subClassOf rdf:ID="description_3"/> </owl:Class>
Example 2-7 also shows that the abouthosts
element from the original POWDER document (line 5 in Example 2-6) is transformed into
a class very similar to those for the IRI sets, this time with a node ID of 'aboutset' (line 17 - 26).
Both descriptorset_1
and descriptorset_2
are defined as the interesection of this set and the various descriptive
properties which ensures that the intended operational semantics of abouthosts
are preserved.
A logical inconsistency is detected if an IRI is asserted to be a sub class of a descriptor set that intersects with an about set of which it is
not a member. The Formal Semantics document [FORMAL] has further detail on the processing of abouthosts
.
As noted in Section 2.1, the scope of a DR may be the union of multiple IRI sets. Example 2-8 below shows a DR for which the scope is all resources on example.com that have a path starting with /foo AND those on example.org that have a path starting with /bar. In POWDER-S, the sub class relationship between each of the IRI sets and the descriptor set is asserted independently.
Example 2-8: A DR for which the scope is the union of two IRI sets
POWDER [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <attribution> <maker sre="http://authority.example.org/foaf.rdf#me" /> <issued>2007-12-14T00:00:00</issued> </attribution> <dr> <iriset> <includehosts>example.com</includehosts> <includepathstartswith>/foo</includepathstartswith> </iriset> <iriset> <includehosts>example.org</includehosts> <includepathstartswith>/bar</includepathstartswith> </iriset> <descriptorset> <ex:color>red</ex:color> <ex:shape>square</ex:shape> <displaytext>Everything on example.com/foo, and everything on example.org/bar, is red and square</displaytext> <displayicon src="http://example.org/icon.png" /> </descriptorset> </dr> </powder>
POWDER-S [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> </rdf:Description> <owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]*)(\:([0-9]+))?\/foo</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="iriset_2"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.bar)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]*)(\:([0-9]+))?\/bar</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="descriptorset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#color" /> <owl:hasValue>red</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#shape" /> <owl:hasValue>square</owl:hasValue> </owl:Restriction> </owl:intersectionOf> <dc:description>Everything on example.com/foo, and everything on example.org/bar, is red and square</dc:description> <foaf:depiction rdf:resource="http://example.org/icon.png" /> </owl:Class> <owl:Class rdf:about="#iriset_1"> <rdfs:subClassOf rdf:resource="#descriptorset_1"/> </owl:Class> <owl:Class rdf:about="#iriset_2"> <rdfs:subClassOf rdf:resource="#descriptorset_1"/> </owl:Class> </rdf:RDF>
POWDER is predicated on the concept of IRI sets — applying descriptions to more than one IRI at a time. This relies on there being some structure to the IRIs used. To a human reader, it would be fairly obvious that all resources with an IRI on composers.example.org that have a path starting with /Mahler would be about a different composer to those with a path starting with /Beethoven. IRI sets allow these relationships to become machine processable.
However, not all Web content is arranged in such clearly delineated fashion and as a result, it is impossible to define a suitable IRI set. For example, a content management system may assign a simple numerical IRI to newly added content irrespective of the type or the subject matter of content available from that IRI. In such a situation, the usefulness of POWDER as a content discovery mechanism is reduced, but not eliminated.
The POWDER document in example 2-9 below contains two descriptions that can be applied to example.org and example.com (defined
in the abouthosts
element), but those
descriptions are not tied to particular IRI sets within a Description Resource.
Example 2-9: A POWDER Document With Descriptors That Can Be Referenced Externally, But with No DRs
POWDER [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <attribution> <maker src="http://authority.example.org/foaf.rdf#me" /> <abouthosts>example.org example.com</abouthosts> </attribution> <descriptorset xml:id="red"> <ex:color>red</ex:color> </descriptorset> <descriptorset xml:id="blue"> <ex:color>blue</ex:color> </descriptorset> </powder>
From a discovery point of view, this tells us that there are red and blue resources available on example.org and example.com but can go no further. Associating a description set with a specific IRI can only be done by linking from a resource to a description, hence the inclusion of the identifiers on the descriptor set elements (which are preserved in POWDER-S). An HTML document at http://www.example.org/page.html might include a link element thus:
<link rel="powder" href="/powder.xml#red" type="application/xml" />
Although example 2-9 does not contain any Description Resources, it does preserve two key elements of POWDER:
Firstly, the description is attributed and therefore an assessment of trust can be made in the same way as any other POWDER document.
Secondly, the attribution element includes an abouthosts
element. This effectively limits the scope of the descriptions
to the declared hosts since if a resource is not available from a listed host, then, as noted in the discussion of Example 2.6 above,
the processor MUST NOT apply the data in the document to that resource.
This is an important point since it would be possible to claim that any resource on the Web is 'red' by including the link element
shown above. This may be what is required (see following section), however, the abouthosts
element allows POWDER
document authors to set an outer limit on where the descriptions can be applied. It is for this reason that we specify that if the
abouthosts
element is included in a POWDER document, then processors MUST NOT, rather than SHOULD NOT or MAY NOT, apply
descriptions within the document to any host other than those listed. This has implications for the specification of a POWDER Processor
see Section 3 below.
It is emphasized that providing descriptions in this way is inferior to the preferred method of explicitly associating them with
IRI sets within a DR. If a POWDER document is to describe all the resources on a given Web site in the same way, then authors should include
a Description Resource with an IRI set defined using the appropriate value of the includehosts
element. This is because
the semantics are different in a subtle but important way:
Within a Description Resource, all IRIs that are instances of an IRI set are described.
The abouthosts
element within the attribution element of a POWDER document states that all resources that are described within
that document are available from the given host(s), it does NOT guarantee that all resources on those hosts are described.
The first of these is clearly a better aid to content discovery.
As shown in the previous section, descriptorset
elements can exist outside a DR. If the POWDER document does not include an
abouthosts
element in its attribution, then such a descriptor set may be used to describe any resource.
However this is the job that RDF vocabularies and OWL ontologies are designed for. Therefore, authors are strongly advised
to create or use existing examples of either of those in preference to a POWDER document without any restriction on where the
descriptions can be applied.
Bearing in mind that warning, some content providers and their suppliers may find it convenient to split Description Resources across several POWDER documents. In example 2-10 below, powder1.xml defines two types of book published by the organization described at http://education.example.org/foaf.rdf#me related to the UK National Curriculum. The publisher sells their books through two online outlets: books.example.com and archive.example.net and therefore restricts its descriptions to those hosts. powder2.xml describes one of those outlets (books.example.com) which brands its Key Stage 1 products as 'robin' and its Key Stage 2 products as 'starling.' By referring to powder1.xml, books.example.com is able to associate the publisher's relevant icon with the correct pages of its own e-commerce portal.
A POWDER processor MUST take full account of the
abouthosts
element in powder1.xml when processing the DRs in powder2.xml.
Example 2-10: Example of a Pre-Defined Descriptors Element and its Usage
powder1.xml [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://education.example.org/vocab#"> <attribution> <maker src="http://education.example.org/foaf.rdf#me" /> <abouthosts>books.example.com archive.example.net</abouthosts> </attribution> <descriptorset xml:id="ks1"> <displaytext>This material is suitable for UK National Curriculum Key Stage 1</displaytext> <displayicon src="http://education.example.org/ks1.png" /> </descriptorset> <descriptorset xml:id="ks2"> <displaytext>This material is suitable for UK National Curriculum Key Stage 2</displaytext> <displayicon src="http://education.example.org/ks2.png" /> </descriptorset> </powder>
powder2.xml [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#"> <attribution> <maker src="http://books.example.com/foaf.rdf#me" /> <issued>2008-03-03</issued> </attribution> <dr> <iriset> <includehosts>books.example.com</includehosts> <includepathstartswith>/robin/</includepathstartswith> </iriset> <descriptorset src="http://education.example.org/powder1.xml#ks1" /> </dr> <dr> <iriset> <includehosts>books.example.com</includehosts> <includepathstartswith>/starling/</includepathstartswith> </iriset> <descriptorset src="http://education.example.org/powder1.xml#ks2" /> </dr> </powder>
Given powder2.xml, a POWDER Processor SHOULD use the descriptor sets defined in
powder1.xml. Such a step is beyond the GRDDL transform so that if powder2.xml is
transformed, it will create a class that merely has a rdfs:seeAlso
annotation thus:
<owl:Class rdf:nodeID="descriptorset_1"> <rdfs:seeAlso rdf:resource="http://education.example.org/powder1.xml#ks1" /> </owl:Class>
However, given the two documents in Example 2-10, a POWDER Processor MAY go further and transform both and create the documents shown in Example 2-11 below.
Example 2-11: POWDER-S Version of Example 2-10
powder1.rdf [RDF]
<rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:owl="http://www.w3.org/2002/07/owl#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://books.example.com/foaf.rdf#me" /> <dcterms:issued>2008-03-03T00:00:00</dcterms:issued> </rdf:Description> <owl:Class rdf:nodeID="aboutset"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue> \:\/\/([^\:\/\?\#\@]+\.)?(books\.example\.com|archive\.example\.net)(\:([0-9]+))?\/ </owl:hasValue> </owl:Restriction> </owl:Class> <owl:Class rdf:nodeID="ks_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#aboutset"/> </owl:intersectionOf> <dc:description>This material is suitable for UK National Curriculum Key Stage 1</dc:description> <foaf:depiction rdf:resource="http://education.example.org/ks1.png" /> </owl:Class> <owl:Class rdf:nodeID="ks_2"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#aboutset"/> </owl:intersectionOf> <dc:description>This material is suitable for UK National Curriculum Key Stage 2</dc:description> <foaf:depiction rdf:resource="http://education.example.org/ks2.png" /> </owl:Class> </rdf:RDF>
powder2.rdf [RDF]
<owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(books\.example\.com)(\:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)*[^\:\/\?\#\@]+(\:([0-9]+))?\/robin/</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="iriset_2"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(books\.example\.com)(\:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)*[^\:\/\?\#\@]+(\:([0-9]+))?\/starling/</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:about="#iriset_1"> <rdfs:subClassOf rdf:resource="powder1.rdf#ks_1"/> </owl:Class> <owl:Class rdf:about="#iriset_2"> <rdfs:subClassOf rdf:resource="powder1.rdf#ks_2"/> </owl:Class>
The pre-defined descriptions of powder1.xml are translated into resource classes with the appropriate
descriptor restrictions, and a class with a nodeID of aboutset
is also created to respect
the abouthosts
element. As noted in the discussion around Example.2.7,
this is used as a restriction on the descriptors so that a logical inconsistency is raised if the
descriptor sets are used to describe a resource on a different host.
In the examples given so far, controlled vocabularies have been used to describe the resources. POWDER also supports free text 'tags' too — that is, key words or short phrases that describe the content — as shown in example 2-12 below.
Example 2-12: Generic Example of a DR Containing a Tagset [XML]
1 <?xml version="1.0"?> 2 <powder xmlns="http://www.w3.org/2007/05/powder#" 3 xmlns:ex="http://example.org/vocab#"> 4 <attribution> 5 <maker src="http://authority.example.org/foaf.rdf#me" /> 6 <issued>2007-12-14T00:00:00</issued> 7 </attribution> 8 9 <dr> 10 <iriset> 11 <includehosts>example.com</includehosts> 12 </iriset> 13 14 <tagset> 15 <tag>London</tag> 16 <tag>Swiss Re</tag> 17 <tag>gherkin</tag> 18 </tagset> 19 </dr> 20 </powder>
The DR in this example does not have a descriptor set, rather it has a tag set (it could have both). Any number of tags may be included as elements within the tag set and these may contain any text (subject to usual XML data encoding rules).
A DR MUST contain at least one tagset
or descriptorset
element, or both.
The tag
element can only be used within a tagset
and specifically MUST NOT be used within a descriptorset
. This is
because the descriptor set element is used to contain values for properties taken from controlled vocabularies
expressed in RDF. A tag set (and only a tag set) may optionally refer to one or more resources that help
to define the meaning of the tags by providing a white space separated list of IRIs as the value
of the ref
attribute.
For example, the tag set in example 2-12 might link to an online encyclopaedia page and an image of the London landmark suggested by the tags thus:
<tagset ref="http://encyclopaedia.example.com/gherkin.html
http://photo.example.com/gherkin.jpg">
<tag>London</tag>
<tag>Swiss Re</tag>
<tag>gherkin</tag>
</tagset>
Full POWDER and POWDER-S versions of this are shown in example 2-13 below.
Example 2-13: Example of a DR Containing a Tagset that links to further information that put the tags in context
POWDER [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <attribution> <maker src="http://authority.example.org/foaf.rdf#me" /> <issued>2007-12-14T00:00:00</issued> </attribution> <dr> <iriset> <includehosts>example.com</includehosts> </iriset> <tagset ref="http://encyclopaedia.example.com/gherkin.html http://photo.example.com/gherkin.jpg"> <tag>London</tag> <tag>Swiss Re</tag> <tag>gherkin</tag> </tagset> </dr> </powder>
POWDER-S [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> </rdf:Description> <owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="tagset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder#tag" /> <owl:hasValue>London</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder#tag" /> <owl:hasValue>Swiss Re</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder#tag" /> <owl:hasValue>gherkin</owl:hasValue> </owl:Restriction> </owl:intersectionOf> <rdfs:seeAlso rdf:resource="http://encyclopaedia.example.com/gherkin.html" /> <rdfs:seeAlso rdf:resource="http://photo.example.com/gherkin.jpg" /> </owl:Class> <owl:Class rdf:about="iriset_1"> <rdfs:subClassOf rdf:resource="#tagset_1"/> </owl:Class> </rdf:RDF>
In much the same way that a Description Resource may contain multiple IRI sets, it may also contain multiple descriptor sets. This is particularly useful where two distinct and independent types of description are applied to different sections of a single Web site. For instance, an editorial policy or trustmark might apply to a whole Web site whereas a description of the content's suitability for children might vary in different sections as the following example shows. Here the whole of movie.example.com is covered by the same trustmark with resources that have IRIs with a path beginning with /after9pm identified as only being suitable for adults. By defining descriptor sets separately within the POWDER document, these can be referenced as needed within the DRs without duplicating data. Separately, from the ordered list, the entity described at http://authority.example.org/foaf.rdf#me has tagged the /latest section with the phrases New Releases and What's Hot.
Example 2-14: An Ordered List of DRs, each with Multiple Descriptor Sets
POWDER [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <attribution> <maker src="http://authority.example.org/foaf.rdf#me" /> <issued>2007-12-14T00:00:00</issued> </attribution> <ol> <dr> <iriset> <includehosts>movie.example.com</includehosts> <pathstartswith>/after9pm</pathstartswith> </iriset> <descriptorset src="#adult" /> <descriptorset src="#trustmark" /> </dr> <dr> <iriset> <includehosts>movie.example.comg</includehosts> </iriset> <descriptorset src="#allages" /> <descriptorset src="#trustmark" /> </dr> </ol> <descriptorset xml:id="adult"> <ex:agemin>18</ex:agemin> </descriptorset> <descriptorset xml:id="allages"> <ex:agemin>0</ex:agemin> </descriptorset> <descriptorset xml:id="trustmark"> <ex:trustedsite>true</ex:trustedsite> </descriptorset> <dr> <iriset> <includehosts>movie.example.com</includehosts> <pathstartswith>/latest</pathstartswith> </iriset> <tageset> <tag>New Releases</tag> <tag>What's hot</tag> </tagset> </dr> </powder>
POWDER [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> </rdf:Description> <owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]*)(\:([0-9]+))?\/after9pm</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:about="#iriset_1"> <rdfs:subClassOf rdf:resource="#adult"/> <rdfs:subClassOf rdf:resource="#trustmark"/> </owl:Class> <owl:Class rdf:nodeID="iriset_2"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class> <owl:intersectionOf rdf:parseType="Collection"> <owl:Class rdf:about="#iriset_2"/> <owl:Class> <owl:complementOf rdf:parseType="Collection"> <owl:Class rdf:about="#iriset_1"/> </owl:complementOf> </owl:Class> </owl:intersectionOf> <rdfs:subClassOf rdf:resource="#allages"/> <rdfs:subClassOf rdf:resource="#trustmark"/> </owl:Class> <owl:Class rdf:nodeID="adult"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#agemin" /> <owl:hasValue>18</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="allages"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#agemin" /> <owl:hasValue>0</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="trustmark"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#trustedsite" /> <owl:hasValue>true</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="iriset_3"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]*)(\:([0-9]+))?\/latest</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="tagset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder#tag" /> <owl:hasValue>New Releases</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder#tag" /> <owl:hasValue>What's Hot</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:about="iriset_3s"> <rdfs:subClassOf rdf:resource="#tagset_1"/> </owl:Class> </rdf:RDF>
The Protocol for Web Description Resources is designed first and foremost as a simple and efficient method of publishing metadata. A POWDER document contains sufficient information to yield a description of any resource that is within the scope of the DR(s) to which it has access. A key function of a POWDER Processor is therefore to return RDF triples that describe candidate resources.
If u is the URI or IRI of a resource, then as a minimum, a POWDER Processor MUST support the
function describe(u)
by returning RDF triples that describe u.
A minimal set of formal constraints are placed on how a POWDER Processor must be realized. It may be a
component in a user agent or some other application that is able to process the descriptions it returns
or a standalone online service. It may use HTTP to collect POWDER documents from the Web or it
may act as a gateway to a repository of Description Resources. It is highly likely therefore that a
real application will support a variety of different functions and options, in particular,
one or more of those related to trust as discussed in Section 5, however, a conformant
POWDER Processor will support the key describe(u)
function.
As an example, imagine a POWDER Processor that has access to the document shown in
Example 3-1. The function call describe('http://www.example.com/')
would return:
<rdf:Description rdf:about="http://www.example.com/"> <ex:color>red</ex:color> <ex:shape>square</ex:shape> <wdrs:describedby rdf:resource="http://...example2-1.xml" /> </rdf:Description>
Notice that the description includes a link to the POWDER document from which the data was derived (this is optional).
The wdrs:describedby
property is discussed further in Section 4.1.3 below.
Where a POWDER Processor has a Web interface, describe(u)
SHOULD be the default function
available by sending an HTTP GET request to its IRI and including the candidate resource as the value for
the parameter u in the query string. The query string should be URL-encoded as defined by XForms 1.0 [XF]
such that, if ipp is the IRI of the POWDER Processor then the above request for a description of http://www.example.com/ would
be made by dereferencing the following IRI:
ipp?u=http%3A%2F%2Fwww.example.com%2F
which would return the RDF/XML document shown below
Example 3-1: Example Result from a POWDER Processor [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about="http://www.example.com/"> <ex:color>red</ex:color> <ex:shape>square</ex:shape> <wdrs:describedby rdf:resource="http://...example2-1.xml" /> </rdf:Description> </rdf:RDF>
If the processor has no information about the candidate resource then it uses the
wdrs:notknownto
property to return the 'not known'
message shown below.
Example 3-2: Example 'Not Known Result' from a POWDER Processor [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:wdrs="http://www.w3.org/2007/05/powder-s#"> <rdf:Description rdf:about="http://www.example.com/"> <wdrs:notknownto rdf:resource="ipp" /> </rdf:Description> </rdf:RDF>
The range of wdrs:notknownto
is the class wdrd:Processor
, defined as the class of
POWDER Processors.
The value for u may be replaced by the word 'referer', in which case the POWDER Processor SHOULD return a description of the IRI given in the HTTP REFERER field (or the not known response). This allows a POWDER Processor to return descriptions of resources that point to it. For example, an XHTML document published at http://www.example.com/ might include the following link element:
<link rel="meta" href="ipp?u=referer" type="application/rdf+xml" />
User agents following that link would receive the response shown in Example 3-1. (N.B. Only the behavior of the POWDER processor is specified here, the relationship type of meta is non normative in this context).
The describe(u)
function SHOULD also support an additional optional parameter, d.
This is the IRI of a POWDER document and may include a fragment identifier as discussed
in Section 2.5. Referring to Example.2-9
we can envisage a document at http://www.example.com/page.html that includes a link element
pointing to /powder.xml#red and construct the function call:
describe(http://www.example.com/page.html, http://www.example.com/powder.xml#red)
or over HTTP as
ipp?u=http%3A%2F%2Fwww.example.com%2F&d=http%3A%2F%2Fwww.example.com%2Fpowder.xml%23red
Alternatively, the document at http://www.example.com/page.html might simply point directly to the POWDER processor with the following link:
<link rel="meta" href="ipp?u=referer&d=http%3A%2F%2Fwww.example.com%2Fpowder.xml%23red" type="application/rdf+xml" />
Dereferencing that IRI returns RDF triples about that specific document.
A conformant POWDER Processor will support the describe(u)
function in accordance with
the specification set out in this document and those to which it refers as follows. The POWDER processor:
abouthosts
element.
If present, the host component of u must be the same as, or a subdomain of, at least one of the hosts
listed. If not, the processor MUST return the not known response.wdrs:describedby
property to point to the POWDER document(s) from which the description was obtained.(see the Formal Semantics document for details of each POWDER format).
The distinctions between how the different encodings of Description Resources arise because all POWDER documents can be transformed into POWDER-BASE. As the name suggests, this is the fundamental format. However, IRI sets are much more easily defined by humans using POWDER and it is anticipated that it will be the predominant format. Where the processor is associated with a data source that does not make use of POWDER, perhaps using a different transform to create POWDER-BASE from a proprietary format and, due to its application environment, it is known with a high degree of certainty that it will never have to process POWDER documents from other sources, then it clearly will not have to support it (or POWDER-S).
POWDER-S is defined to allow Description Resources to be processed as part of the more general Semantic Web. The application context must therefore determine whether a POWDER processor should support it.
There is no requirement for a processor to use the XSLT transforms associated with the POWDER namespaces so long as the output is consistent with processors that do.
As noted, there are no other formal conformance criteria for a POWDER Processor, however, good implementations will go significantly further. For example, they may offer to return results in alternative serializations or to take account of the attribution data when responding to requests.
The inverse of the describe(u)
function — 'find resources with these properties' —
would be very useful in several of the scenarios set out in the POWDER use cases. Where
the processor is acting as a gateway to a specific repository it is likely to be possible to specify a simple syntax
for queries that would return DRs or IRI sets that include descriptor sets matching given properties. Since a
descriptor set may contain RDF/XML with few constraints, a fully flexible function of this type could only be
provided by supporting SPARQL queries against POWDER-S documents, noting that this requires an implementation of the
POWDER semantic extension by the requesting agent.
A given resource (hereafter known as the described resource) may relate itself to a POWDER document. There are several methods to define such a relationship, detailed below.
link
ElementsIn HTML documents, the link
element can be used to point to a POWDER document with the
relationship type of 'powder' as shown in Example.3-1.
The relationship type is defined in the @@@POWDER profile@@@ (should be at http://www.w3.org/2007/powder-profile)
document which should therefore be referenced in the head
tag.
The WG is considering registering the powder
relationship type with IANA and the HTML5 WG
Documents MAY also include any of the attribution data from the POWDER document in meta tags. In particular, the
maker
field is likely to be useful to user agents deciding whether or not to fetch the full POWDER
document. Any attribution data encoded in meta tags within an HTML document should be the same as that in the POWDER document.
In case of discrepancy, the POWDER document should be taken as more authoritative.
N.B. the value of the rel
attribute is a white space separated list so other relationship types
may be included too. For example, it may be desirable to give processors a clue as to which descriptive vocabulary or vocabularies
is/are used in the DR(s) in the POWDER document. Again, such relationship types may need to be defined in a profile document.
Example 4-1: using the link
element to relate an XHTML document to a DR [HTML]
<html xmlns="http://www.w3.org/1999/xhtml"> <head profile="http://www.w3.org/2007/11/powder-profile"> <meta name="wdr.maker" content="http://authority.example.org/foaf.rdf#me"/> <link rel="powder" href="powder.xml" type="application/xml"/> <title>Welcome to example.com </title> </head> <body> <p>Today's content is ....</p> </body> </html>
Note that this approach requires the described resource to be requested and parsed in order to find the relevant POWDER document's location. This may be acceptable for data warehousing, for example retrieving DRs asynchronously to a user request, so that the metadata about the described resource can be inspected and usage trends compiled. However a more efficient method of associating resources with a POWDER document is to use the HTTP Link Header.
POWDER WG would like to see the HTTP Link Header re-instated as described in Mark Nottingham's (updated) draft (or for the equivalent functionality to be made available in some other fashion). This document and its use for POWDER was recently endorsed by the TAG. See Proposal4a and Proposal5 in http://www.w3.org/2001/tag/2008/05/20-minutes#item06. Until such time as the draft is moved to RFC status, the following section is formally flagged as a feature at risk.
The HTTP Link Header [REF] is an alternative to the HTML link
element and has very similar semantics
such that the following two links are equivalent:
<link rel="powder" href="powder.xml" type="application/xml" />
Link: <powder.xml>; rel="powder" type="application/xml";
User agents may discover the location of the POWDER document by inspecting the HTTP Response headers and pass it to a POWDER processor without having to parse the resource itself. This has several distinct advantages:
describedby
PropertyWe define the RDF property wdrs:describedby
with a domain of rdf:resource and
a range of wdrs:Document
. This is the class of POWDER documents and is a sub class of foaf:Document
.
In formats that support RDF properties directly it is appropriate to link a resource to a POWDER document that describes it through the
wdrs:describedby
predicate rather than the powder
relationship type. For example, a document
might be part of a collection about a particular topic described in a DR. Such a document might be annotated
using RDFa as shown in example 4-2 below.
Example 4-2: RDFa snippet using wdrs:describedby
[HTML]
1 <html 2 xmlns="http://www.w3.org/1999/xhtml" 3 xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" 4 > 5 <head> 6 <title>The English Civil War</title> 7 <link rel="wdrs:describedby" href="http://ecw.example.org/powder1.xml" /> 8 </head> 9 <body> 10 … 11 <p>Charles I came to the throne believing in his 12 <a href="http://monarchy.example.org/divine_right.html">Divine Right</a> to rule... 13 … 14 </body> 15 </html>
Here the active document is linked to a description through the link
element in the head
with the relationship type defined using the wdrs:describedby
property (line 7). The POWDER document (powder1.xml) SHOULD describe the active document and may or
may not provide a description of other resources linked from it. For the purposes of this example we'll assume
that powder1.xml describes the whole of the Web site that includes this document as being a source of information
that is recommended for school study of the English Civil War.
Notice that the text in example 4-2 includes a link to another document on another host in line 12 (divine_right.html). Suppose that document, and others on the monarchy.example.org Web site, are described by a different POWDER document. It is possible to use RDFa to link to a POWDER document describing divine_right.html as shown in lines 12-13 in example 4-3 below.
Example 4-3: RDFa snippet using two wdrs:describedby
properties [HTML]
1 <html 2 xmlns="http://www.w3.org/1999/xhtml" 3 xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" 4 > 5 <head> 6 <title>The English Civil War</title> 7 <link rel="wdrs:describedby" href="http://ecw.example.org/powder1.xml" /> 8 </head> 9 <body> 10 … 11 <p>Charles I came to the throne believing in his 12 <a about="http://monarchy.example.org/powder2.xml" 13 rev="wdrs:describedby" 14 href="http://monarchy.example.org/divine_right.html">Divine Right</a> to rule... 15 … 16 </body> 17 </html>
Note the use of the rev
relationship type in line 13 which effectively switches round the subject and object
of the triple. An RDFa processor will extract the following two triples from this snippet:
<> wdr:describedby <http://ecw.example.org/powder1.xml> <http://monarchy.example.org/divine_right.html> wdr:describedby <http://monarchy.example.org/powder2.xml>
A POWDER-aware Web browser may use the description provided in powder2.xml to decide to render the hyperlink in different ways. For example, if the document about Divine Right is not suitable for display on mobile devices, the browser may not include the hyperlink at all when the primary document is viewed on a handheld device but would do so on a desktop device.
POWDER may also provide useful annotations in syndication feeds, again with the
describedby
property providing the link. Example 4-4 shows an ATOM feed
of the documents discussed in example 4-3 that links to the same two different POWDER documents.
Example 4-4: ATOM feed with links to POWDER documents [XML]
<?xml version="1.0" encoding="utf-8"?> <feed xmlns="http://www.w3.org/2005/Atom" xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" > <wdrs:describedby>http://ecw.example.org/powder1.xml</wdrs:describedby> <title>The English Civil War</title> <link href="http://ecw.example.org/"/> <updated>2007-10-30T15:00:00Z</updated> <author> <name>John Doe</name> </author> <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id> <entry> <title>Charles I</title> <link href="http://ecw.example.org/charles1.html"/> <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id> <updated>2007-06-04T09:39:21Z</updated> <summary>Charles I came to the throne believing in his Divine Right to rule...</summary> </entry> <entry> <wdrs:describedby>http://monarchy.example.org/powder2.xml</wdrs:describedby> <title>Divine Right</title> <link href="http://monarchy.example.org/divine_right.html"/> <id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6b</id> <updated>2007-06-06T13:43:54Z</updated> <summary>Divine Right was claimed by several English monarchs, notably Charles I...</summary> </entry> </feed>
The feed element is linked to powder1.xml which is a hint, not a guarantee, that it describes many or all of the items in the feed. The second item in the feed is described by a different POWDER document.
It is worth noting that the structure of the ATOM feed plays no part in determining what is described by the POWDER documents — this is only defined in the IRI sets within the DRs they contain. For the avoidance of doubt, powder1.xml does not fulfill the role of 'default' description that is then overridden by powder2.xml.
As described in Section 3, a POWDER processor may be set up as an online
service through which RDF triples about a particular resource may be obtained. The simplest way to achieve this is
to append the IRI of the POWDER processor with ?u=referer
, adding the IRI of a
POWDER data source if necessary, and include it in either an HTML or HTTP Link.
RDF-aware user agents, including those without any POWDER implementation, will be able to process the data received.
POWDER documents may refer to each other to facilitate easier discovery by user agents. The
seealso
element is a child element of the root element, may appear any number of times, and
uses the ref attribute to point to external POWDER documents. The data is retained in POWDER-S where it
becomes an rdfs:seeAlso
property with the POWDER-S document as its subject as shown in
Example 4-5 below.
Example 4-5: A POWDER Document Linking to Another
POWDER [XML]
<?xml version="1.0"?> <powder xmlns="http://www.w3.org/2007/05/powder#" xmlns:ex="http://example.org/vocab#"> <seealso ref="http://another.example.com/powder2.xml" /> <attribution> <maker ref="http://authority.example.org/foaf.rdf#me" /> <issued>2007-12-14</issued> </attribution> <dr> <iriset> <includehosts>example.com</includehosts> </iriset> <descriptorset> <ex:color>red</ex:color> <ex:shape>square</ex:shape> <displaytext>Everything on example.org is red and square</displaytext> <displayicon ref="http://example.org/icon.png" /> </descriptorset> </dr> </powder>
POWDER-S [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> <dcterms:issued>2007-12-14</dcterms:issued> <rdfs:seeAlso rdf:resource="http://another.example.com/powder2.xml" /> </rdf:Description> <owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">\:\/\/([^\:\/\?\#\@]+\.)?(example\.com)(:([0-9]+))?\/</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="descriptorset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#color" /> <owl:hasValue>red</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://example.org/vocab#shape" /> <owl:hasValue>square</owl:hasValue> </owl:Restriction> </owl:intersectionOf> <dc:description>Everything on example.org is red and square</dc:description> <foaf:depiction rdf:resource="http://example.org/icon.png" /> </owl:Class> <owl:Class rdf:about="#iriset_1"> <rdfs:subClassOf rdf:resource="#descriptorset_1"/> </owl:Class> </rdf:RDF>
Example 4-5 is a repeat of Examples 2-1 and 2-3 to show the seealso
element.
There are no normative rules on how to publish large numbers of Description Resources. However, individuals or organizations that create DRs are encouraged to make them available both as POWDER and POWDER-S documents. The latter would best be exposed through a SPARQL endpoint. It is noteworthy that if a POWDER document is edited, it SHOULD be made available at a new IRI. As a practical step, that IRI is generally best discovered through an HTTP 302 redirect from an IRI published as the 'latest location.'
The publisher is, of course, free to set up whatever system they feel appropriate but as there are no normative rules it is essential to provide adequate documentation, perhaps including sample queries that yield results that can be processed efficiently.
Examples are provided in the Primer.
Trust is a critical aspect of Description Resources, however, trust is very much a matter of opinion. The level of trust demanded of a given DR will depend on what the description says and to what use it will be put. For example, an individual user finding a DR that declares a Web site to offer children's birthday party ideas can make his/her own assessment of its quality and usefulness. In contrast, a multi-million dollar business will need very strong assurance that a DR declaring a Web site to be medically accurate and freely available is trustworthy before including it in a portal of high quality, license-free, healthcare materials. For this reason, we do not define a single trust mechanism that must be used. Rather, the following sections describe a variety of different methods of adding trust to DRs, some of which may be used in combination. Where applicable, we define vocabulary terms designed to aid the building of trust.
These measures add to POWDER's inherent trust model, namely:
authenticate
PropertyAny method provided by a DR author for adding trust to their descriptions needs to be discoverable. To this end,
we define the authenticate
property with a domain of foaf:Agent
. That is, it's part of
the description of an entity that creates POWDER documents, not of the POWDER documents themselves.
The range of authenticate
is simply rdfs:Resource
and so its value can be machine-processable, such as a WSDL document, or a human-readable document describing
any authentication services that the DR author offers or steps he/she recommends.
The following snippet repeats the attribution
element of Example 2-2 and
includes a pointer to a document that describes how to authenticate the Exemplary Description Authority's
POWDER documents.
<attribution> <maker> <foaf:Organization> <foaf:homepage rdf:resource="http://authority.example.org/" /> <foaf:name>The Exemplary Description Authority</foaf:name> <foaf:nick>EDA</foaf:nick> <authenticate rdf:resource="http://authority.example.org/how_to_authenticate.html" /> </foaf:Organization> </maker> </attribution>
Trust in Description Resources may readily be enhanced through third party certification. That is, an entity can publish data that is identifiable through its origin and/or a digital signature that states that the named entity certifies that the claims and assertions made in an identified POWDER document are correct. The level of trust that can be placed in the data then becomes equivalent to the level of trust held in the certification body. Such certificates may themselves by expressed in a DR as exemplified below.
Example 5-1: Example of a Certificate, expressed as a DR [XML]
1 <?xml version="1.0"?> 2 <powder xmlns="http://www.w3.org/2007/05/powder#"> 3 <attribution> 4 <maker src="http://authority.example.org/foaf.rdf#me" />> 5 <issued>2007-12-14T00:00:00</issued> 6 <validfrom>2008-01-01T00:00:00</validfrom> 7 <validuntil>2008-12-31T00:00:00</validuntil> 8 </attribution> 9 <dr> 10 <iriset> 11 <includeresources>http://www.example.com/powder.xml</includeresources> 12 </iriset> 13 <descriptorset> 14 <sha1sum>j6lwx3rvEPO0vKtMup4NbeVu8nk=</sha1sum> 15 <certified>true</certified> 16 <displaytext>authority.example.org certifies that claims made by example.com are true. Valid throughout 2008.</displaytext> 17 <displayicon src="http://authority.example.org/icon.png" /> 18 </descriptorset> 19 </dr> 10 </powder>
This example introduces a number of features.
It is the nature of certificates that they have a period of validity. Trustmarks are typically awarded for a period of a year,
for example. To support this, POWDER defines two elements: validfrom
and
validuntil
in lines 6 and 7.
These elements are of type xsd:date and have the following operational semantics:
A POWDER document is temporally valid unless:
validfrom
element present and today's date precedes itvaliduntil
date and today's date is after the date given.Temporal validity is independent of trust, that is, a POWDER document that is temporally invalid may be trusted by a user (or user agent). Similarly, a temporally valid document may not be trusted. However, from a policy perspective, the publisher of any Description Resource should be prepared to stand by their claims for the entirety of any stated validity period.
If an HTTP cache header is set, the valid until dates are only applicable within the expiry period. Thus a processor MAY NOT continue to use the DR beyond its cache period until a fresh copy of the DR has been retrieved.
There are no formal semantics associated with validfrom
and validuntil
.
There are two further features shown in Example 5-1 that have not been discussed in this document previously.
In line 14, the descriptor set includes the sha1sum
element
which contains a SHA-1 Sum of the (one) described resource. Although not formalized
in the semantics of POWDER,
this element provides processors with an integrity checking mechanism. The publisher of Example 5-1 is providing a very precise description of
the document at http://www.example.com/powder.xml. User agents are therefore empowered to calculate a SHA-1 hash of the described
resource and use that to decide whether or not to trust the data. The sha1sum
descriptor takes a single hash as its
value and may only appear once in a descriptor set. It is therefore only useful when describing a single resource, as is the case in
Example 5-1.
Since the expression of certificates in this way is at the heart of several POWDER use cases [USECASES] we also
define the certified
element which has a data type of xsd:boolean.
The inverse relationship is also supported by the certifiedby
element. That is, the attribution
element in
http://www.example.com/powder.xml may include a pointer to this certificate by giving its IRI as the value of the certifiedby
element.
Only complete POWDER documents may be certified, not individual DRs.
Example 5-1 is shown in its Semantic POWDER form below.
Example 5-2: Example of the certificate in Example 5-1, expressed in POWDER-S [RDF/XML]
<?xml version="1.0"?> <rdf:RDF xmlns:wdrs="http://www.w3.org/2007/05/powder-s#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:owl="http://www.w3.org/2002/07/owl#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/0.1/" xmlns:ex="http://example.org/vocab#"> <rdf:Description rdf:about=""> <foaf:maker rdf:resource="http://authority.example.org/foaf.rdf#me" /> <dcterms:issued>2007-12-14T00:00:00</dcterms:issued> <wdrs:validfrom>2008-01-01T00:00:00</wdrs:validfrom> <wdrs:validuntil>2008-12-31T00:00:00</wdrs:validuntil> </rdf:Description> <owl:Class rdf:nodeID="iriset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#matchesregex" /> <owl:hasValue rdf:datatype="http://www.w3.org/2001/XMLSchema-datatypes#string">^(http\:\/\/www\.example\.com\/powder\.xml)$</owl:hasValue> </owl:Restriction> </owl:intersectionOf> </owl:Class> <owl:Class rdf:nodeID="descriptorset_1"> <owl:intersectionOf rdf:parseType="Collection"> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#certified" /> <owl:hasValue>true</owl:hasValue> </owl:Restriction> <owl:Restriction> <owl:onProperty rdf:resource="http://www.w3.org/2007/05/powder-s#sha1sum" /> <owl:hasValue>j6lwx3rvEPO0vKtMup4NbeVu8nk=</owl:hasValue> </owl:Restriction> </owl:intersectionOf> <dc:description>authority.example.org certifies that claims made by example.com are true. Valid throughout 2008.</dc:description> <foaf:depiction rdf:resource="http://authority.example.org/icon.png" /> </owl:Class> <owl:Class rdf:about="#iriset_1"> <rdfs:subClassOf rdf:resource="#descriptorset_1"/> </owl:Class> </rdf:RDF>
Example 5-1 is a POWDER document that contains a single DR that describes a single resource - another POWDER document at http://www.example.com/powder.xml. The same resource could be described using core Semantic Web technologies but POWDER offers a number of additional features so that, in effect, Example 5-1 can certify that http://www.example.com/powder.xml is true.
First of all, like all POWDER documents, Example. 5-1 is attributed to an identified entity. That entity's
FOAF description is likely to include the authenticate
property described in
section 5.1, giving information on how its DRs may be authenticated.
Secondly, POWDER supports time-limited assertions (albeit through informal semantics). Operationally, Example 5-1 is only valid for the 2008 calendar year.
Thirdly, the DR includes text and graphics that can be displayed to the end user, providing a readily accessible human-readable representation of the machine-processable data.
Fourthly, by providing a SHA1 hash of the described resource, the publisher of the certificate is making it clear exactly what it is certifying and that if the described document is tampered with (and therefore leads to a different hash) the description will no longer be accurate and should probably be disregarded.
supportedby
PropertyThe certification mechanism detailed in the previous section entails a direct relationship between the content provider (or at least the
DR author) and a certification body. The supportedby
property is similar in that it points to a third party from which data is available that will
confirm the claims and assertions made in the DR, however, there need not be a direct relationship between the parties concerned. The DR author may
discover independently that a third party shares their view and wishes to adduce further evidence to support their own description by pointing
to the external body. One scenario in which this might obtain is described in section 2.1.7 of the Use Cases document [USECASES].
There, a DR is used to declare a Web site to be suitable for children with external support for the claim coming from a company that offers a Web
site classification service.
In common with authenticate
and certifiedby
, supportedby
has a range of rdfs:Resource and this
may be either a machine-processable or human-readable document. supportedby
can be an element within the attribution element or
an individual DR.
Add in example of mobileOK Basic conformance with supporting evidence from the checker.
Description Resources exist independently of the content they describe and are dereferenced from an IRI of their own. This is usually discovered by following a link from the described content. If the Description Resource is hosted on a trusted server, typically one operated by a trustmark scheme or certification body, then the trustworthiness of the DR is equal to the trustworthiness of the server and its operator.
Imagine good.example.com has a commercial relationship with powder.example.org. The operators of good.example.com go through a review process run by powder.example.org and are then entitled to include a tag like the one below in the code of their Web pages.
<link rel="powder" href="http://powder.example.org/dr46" type="application/xml" />
The document at powder.example.org remains entirely under the control of the reviewer who is free to change or remove it at any time.
N.B. Any such change must take account of any valid until date given in the document and the fact that a POWDER-aware user agent may cache DRs until that date occurs. The Primer has more to say about this.
It is fundamental aspect of RDF that descriptive terms are explicitly defined by IRI. Therefore if a particular descriptive vocabulary becomes widely used, it will mean the same thing wherever it is found. This is important when deploying content analysis software that uses machine-learning techniques. Once the software has been trained to recognize content matching descriptions made using a particular vocabulary, where DRs are encountered using that same vocabulary, the newly discovered content can be analyzed and a probability of its accuracy be calculated.
The methods cited here do not comprise an exhaustive list. Other techniques, such as XML Signature [XMLSIG] and Web of Trust [WOT], may be equally applicable. As noted in the introduction, trust is a human judgment that can only be made by weighing the likelihood that the data is true against the consequences of it being false. This judgment is highly dependant on the circumstances under which the need to extend trust arises. It is clear, however, that Description Resources are unlikely to be trusted in isolation and that both their publishers and consumers will only benefit from their existence if one or more techniques for enhancing trust are employed.
The editors duly acknowledge the earlier work in thia area carried out by the Web Content Label Incubator Activity, especially the contribution made by Jo Rabin. David Booth and Jeremy Carroll of HP contributed substantaily to the operational/semantic model for POWDER with further contributions from Dan Brickley and support from all members of the POWDER Working Group.
As noted in the Status of the Document, this draft represents a very substantial change from the first public working draft. Wholesale changes have been made thoughout.
Two significant changes have been introduced in this version:
Other specific changes are recorded below.
maker
element.wdr
namespace)Element Name | Content | Cardinality | Introduced |
---|---|---|---|
powder | attribution , dr , ol , descriptorset , tagset , seealso | The Root Element | Section 2.1 |
attribution | maker , issued , abouthosts , validfrom , validuntil , RDF/XML (excluding blank nodes) | Required | Section 2.1 |
maker | MUST contain or refer to an RDF class (or subclass) of type foaf:Agent | Required | Section 2.1 |
issued | xsd:date | Optional | Section 2.1 |
dr | iriset (1 or more) plus either 1 descriptorset , 1 tagset or both descriptorset and tagset | Optional | Section 2.1 |
iriset | See Grouping of Resources document [GROUP] | At least 1 in each dr | Section 2.1 |
descriptorset | displaytext , displayicon , sha1sum , certified , supportedby , RDF/XML (excluding blank nodes), or a reference to another descriptorset element. See Formal Semantics document [FORMAL] for full details. Also displaytext and displayicon . | Exactly 1 required as child element of dr unless tagset is present. Any number may be a child elements of powder | Section 2.1 |
displaytext | xsd:string | Optional | Section 2.1 |
displayicon | None, but the ref attribute is the IRI of an image and is of type xsd:anyURI | Optional | Section 2.1 |
ol | At least 1 dr | Optional | Section 2.3 |
abouthosts | White space separated list of hosts. When this element is present, descriptions within the document MUST NOT be applied to resources available from other hosts. | Optional | Section 2.3 and Section 2.6 |
tagset | At least 1 tag | Optional | Section 2.7 |
tag | xsd:string | At least 1 within a tagset | Section 2.7 |
seealso | None, but the ref attribute is of type xsd:anyURI | Optional | Section 4.3 |
validfrom | xsd:date | Optional | Section 5.2 |
validuntil | xsd:date | Optional | Section 5.2 |
sha1sum | A SHA-1 sum of the described resource | Optional | Section 5.2 |
certified | An element of type xsd:boolean used when a DR certifies another resource. | Optional | Section 5.2 |
certifiedby | None, but the ref attribute is of type xsd:anyURI which links a DR to another that certifies. | Optional | Section 5.2 |
supportedby | None, but the ref attribute is of type xsd:anyURI which is a pointer to some other data source that supports the claims made in the DR. | Optional | Section 5.3 |
wdrs
namespace)Term | Notes | Type | Introduced |
---|---|---|---|
matchesregex | RDF/OWL tools must understand the POWDER Semantic Extension to process the semantics of this property. | RDF Data Property | Section 2.2 |
notknownto | Property used by a POWDER Processor that it does not have any information about a particular IRI | RDF Data Property | Section 3 |
Processor | The class of POWDER Processors | RDF Class | Section 3 |
describedby | An RDF property that links a described resource to a POWDER document. For use with RDFa and other rich formats. | RDF Data Property | Section 4.1.3 |
Document | The class of POWDER documents | RDF Class | Section 4.1.3 |
authenticate | An RDF property that links a foaf:Agent class to a resource describing how to authenticate its DRs. | RDF Data Property | Section 5.1 |