RDF Primer - The Diigo Meta page

• 16 Mar 12
  

  axel4axel
  • triple
  • triple
• 28 Feb 12
  

  jaserad

  Module1.1.2 NED11 Curtin Uni Bookmarks bar imported

• 15 Feb 12
  

  Robert Verdes

  The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic concepts of RDF and describes its XML syntax. It describes how to define RDF vocabularies using the RDF Vocabulary Description Language, and gives an overview of some deployed RDF applications. It also describes the content and purpose of other RDF specification documents.

  rdf primer semantic-web w3c semantic

  • information about resources
  • particularly intended for representing metadata
  • title, author, and modification date
  • copyright and licensing information
  • However, by generalizing the concept of a "Web resource", RDF can  also be used to represent information about things that can be  identified on the Web, even when they cannot be directly  retrieved on the Web.
  • availability schedule
  • items available from on-line shopping facilities
  • RDF provides a common framework for expressing this  information
  • The ability to exchange information between  different applications means that the information may be made  available to applications other than those for which it was  originally created.
  • describing
  • identifying
  • suitable for processing by machines
  • a system of machine-processable identifiers
  • a machine-processable language
  • All  URIs share the property that different persons or organizations  can independently create them
  • To be more precise, RDF uses URI  references [URIS].
  • Literals may not be used as subjects or  predicates in RDF statements.
  • what is fundamental  to RDF is the graph model of the statements
  • RDF refers to a set of URIrefs (particularly a set intended for a specific purpose) as a vocabulary
  • a common namespace URIref will be chosen for all terms in a vocabulary, typically a URIref under the control of whoever is defining the vocabulary.
  • For instance,
  • http://www.example.org/terms/ for terms it uses in its business
  • RDF uses this same approach to define its own vocabulary of terms with special meanings in RDF. The URIrefs in this RDF vocabulary all begin with http://www.w3.org/1999/02/22-rdf-syntax-ns#, conventionally associated with the QName prefix rdf:.  The RDF Vocabulary Description Language (described in Section 5) defines an additional set of terms having URIrefs that begin with http://www.w3.org/2000/01/rdf-schema#, conventionally associated with the QName prefix rdfs:.
  • http://www.example.org/staffid/ to identify its employees
  • The RDF model only recognizes full URIrefs; it does not "look inside" URIrefs or use any knowledge about their structure. In particular, RDF does not assume there is any relationship between URIrefs just because they have a common leading prefix
  • Moreover, there is nothing that says that URIrefs with different leading prefixes cannot be considered part of the same vocabulary.
  • sometimes an organization will use a vocabulary's namespace URIref as the URL of a Web resource that provides further information about that vocabulary.
  • RDF imposes no restrictions on how many statements using a given URIref as predicate can appear in a graph to describe the same resource.
  • the advantages of using URIrefs as RDF's  basic way of identifying things.
  • instead of  identifying the creator of the Web page by  the character string "John Smith", he has been assigned a URIref
  • the creator of the page is not the  character string "John Smith", or any one of the thousands of  people named John Smith, but the particular John Smith  associated with that URIref (whoever created the URIref defines  the association)
  • Moreover, since there is a URIref to refer to  John Smith, he is a full-fledged resource, and   additional information can be recorded about him, simply by adding  additional RDF statements with John's URIref as the subject.
  • RDF uses URIrefs as  predicates in RDF statements.
  • Using URIrefs to  identify properties is important for a number of reasons.
  • it distinguishes the properties one person may use from  different properties someone else may use that would otherwise be  identified by the same character string
  • For instance, in the  example in Figure  4, example.org uses "name" to mean someone's full name  written out as a character string literal (e.g., "John Smith"),  but someone else may intend "name" to mean something different  (e.g., the name of a variable in a piece of program text). A  program encountering "name" as a property identifier on the Web  (or merging data from multiple sources) would not necessarily be   able to distinguish these uses.
  • Also, using URIrefs to identify properties   enables the properties to be treated as resources themselves.  Since properties are resources, additional  information can be recorded about them (e.g., the English description of what  example.org means by "name"), simply by adding additional RDF  statements with the property's URIref as the subject.
  • RDF's use of URIrefs does not solve all identification  problems because, for example, people can still use different  URIrefs to refer to the same thing.
  • However, even when synonyms are created, the fact that  these different URIrefs are used in the commonly-accessible  "Web space" provides the opportunity both to identify  equivalences among these different references, and to migrate  toward the use of common references.
  • it is important to distinguish between any meaning that RDF itself associates with terms (such as dc:creator in the previous example) used in RDF statements and additional, externally-defined meaning that people (or programs written by those people) might associate with those terms.
  • Moreover, based on their understanding of a given vocabulary, people can write RDF applications to behave in accordance with the special meanings assigned to URIrefs from that vocabulary, even though that meaning will not be accessible to RDF applications not written in that way.
  • suppose John's address needed to be recorded as a  structure consisting of separate street, city, state,  and postal code values
  • information like this is represented in RDF by  considering the aggregate thing to be described (like  John Smith's address) as a resource, and then making statements  about that new resource.
  • This way of representing structured information in RDF can   involve generating numerous "intermediate" URIrefs   such as exaddressid:85740 to represent aggregate concepts such as  John's address. Such concepts may never need to be referred to  directly from outside a particular graph, and hence may not  require "universal" identifiers.
  • This blank  node serves its purpose in the drawing without needing a  URIref, since the node itself provides the necessary  connectivity between the various other parts of the graph.
  • triples use blank  node identifiers, having the form _:name, to  indicate the presence of blank nodes.
  • In a triples representation of a graph, each distinct blank  node in the graph is given a different blank node identifier.
  • Unlike URIrefs and literals, blank node identifiers are not  considered to be actual parts of the RDF graph
  • Blank node identifiers also have significance only within  the triples representing a single graph
  • If  it is expected that a node in a graph will need to be  referenced from outside the graph, a URIref should be assigned  to identify it.
  • blank node identifiers may not be used as  predicates in triples
  • an important aspect of RDF: RDF  directly represents only binary relationships
  • Blank nodes also provide a way to more accurately make  statements about resources that may not have URIs, but that are  described in terms of relationships with other resources that  do have URIs.
  • For example, when making statements  about a person, say Jane Smith, it may seem natural to use a  URI based on that person's email address as her URI, e.g.,  mailto:jane@example.org. However, this approach can  cause problems. For example, it may be necessary to record information  both about Jane's mailbox (e.g., the server it is on) as well as  about Jane herself (e.g., her current physical address), and using a  URIref for Jane based on her email address makes it difficult  to know whether it is Jane or her mailbox that is being described.   The same problem exists when a company's Web page URL, say  http://www.example.com/, is used as the URI of the  company itself. Once again, it may be necessary to record information  about the Web page itself (e.g., who created it and when) as well as  about the company, and using http://www.example.com/  as an identifier for both makes it difficult to know which  of these is the actual subject.
  • When Jane herself  does not have a URI, a blank node provides a more accurate way  of modeling this situation. Jane can be represented by a blank  node, and that blank node used as the subject of a statement  with exterms:mailbox as the property  and the URIref mailto:jane@example.org as  its value. The blank node could also be described with an  rdf:type property having a value of  exterms:Person (types are discussed in more detail  in the following sections), an exterms:name property  having a value of "Jane Smith", and any other  descriptive information that might be useful,
  • the blank node can be read as "there  is a resource".
  • In practice, using blank nodes instead of URIrefs in these  cases does not change the way this kind of  information is handled very much.
  • Using a blank node to  represent this "someone" is just a more accurate way to  represent the real world situation.
  • some  RDF-based schema languages allow specifying that certain  properties are unique identifiers of the resources they  describe.
  • Using blank nodes in this way can also help avoid the use of  literals in what might be inappropriate situations.
  • Finally, the example above giving Jane's age as 26 illustrates the fact that sometimes the value of a property may appear to be simple, but actually may be more complex. In this case, Jane's age is actually 26 years, but the units information (years) is not explicitly given. Such information is often omitted in contexts where it can be safely assumed that anyone accessing the property value will understand the units being used. However, in the wider context of the Web, it is generally not safe to make this assumption.
  • The common practice in  programming languages or database systems is to provide this  additional information about how to interpret a literal  by associating a datatype with the  literal
  • An RDF typed literal is formed by pairing a string  with a URIref that identifies a particular datatype. This  results in a single literal node in the RDF graph with the pair as the literal.  The value represented by the typed literal is the value that   the specified datatype associates with the specified string.
  • The datatypes used in typed literals are defined   externally to RDF, and identified by their datatype  URIs.
  • RDF typed literals simply provide a way to explicitly  indicate, for a given literal, what datatype should be used to  interpret it.
  • There is one exception: RDF defines a built-in datatype with the  URIref rdf:XMLLiteral to represent XML content as a literal  value.
  • Type conversions would still be required when  moving information between systems having different sets of datatypes
  • RDF datatype concepts are based on   a conceptual framework  from XML Schema datatypes [XML-SCHEMA2], as described  in RDF  Concepts and Abstract Syntax [RDF-CONCEPTS].   This conceptual framework defines a datatype as consisting of:
  • A set of values, called the value space,
  • A set of character strings, called the lexical space,
  • A lexical-to-value mapping
  • Not all datatypes are suitable for use in RDF. For a datatype   to be suitable for use in RDF, it  must conform to the conceptual framework just described.
  • For example, xsd:duration does  not have a well-defined value space, and xsd:QName requires an  enclosing XML document context. Lists of the XML Schema datatypes  that are currently considered suitable and unsuitable for use in  RDF are given in [RDF-SEMANTICS].
  • the actual interpretation of a   typed literal appearing in an RDF graph (e.g., determining  the value it denotes) must be performed by software  that is written to correctly process not only RDF, but the  typed literal's datatype as well.
  • even when a URIref does identify a datatype, RDF  itself does not define the validity of pairing that datatype  with a particular literal. This validity can only be determined  by software written to correctly process that particular datatype.
  • RDF draws upon ideas from  knowledge representation, artificial intelligence, and data  management, including Conceptual Graphs, logic-based knowledge  representation, frames, and relational databases. Some possible  sources of background information on these subjects include [SOWA], [CG], [KIF], [HAYES], [LUGER], and [GRAY].
  • rdf:about="http://www.example.org/index.html"
  • rdf:resource="http://www.example.org/staffid/85740"
  • Specifically,  a statement with a blank node as its subject can be written in  RDF/XML using an rdf:Description element with  an rdf:nodeID attribute instead of an  rdf:about attribute. Similarly, a statement with a  blank node as its object can be written using a property  element with an rdf:nodeID attribute instead of an  rdf:resource attribute.
  • rdf:nodeID="abc"
  • rdf:nodeID="abc"
  • rdf:datatype=  "http://www.w3.org/2001/XMLSchema#date"
  • XML entities can be used in RDF/XML to improve readability   in such cases, by providing an additional abbreviation   facility for URIrefs. Essentially, an XML entity declaration   associates a name with a string of characters. When the entity   name is referenced elsewhere within an XML document, XML processors replace   the reference with the corresponding string. For example, the   ENTITY declaration (specified as part of a DOCTYPE  declaration at the beginning of the RDF/XML document):
  • <!DOCTYPE rdf:RDF [<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">]>
  • "&xsd;date"
  • Although RDF does not specify or control how URIrefs are  assigned to resources, sometimes it is desirable to achieve the  effect of assigning URIrefs to resources that are part  of an organized group of resources.
  • An important difference from previous examples  is that, in line 5, the rdf:Description  element has an rdf:ID attribute instead of an  rdf:about attribute. Using rdf:ID specifies  a fragment identifier, given by the  value of the rdf:ID attribute (item10245 in  this case, which might be the catalog number assigned by  example.com), as an abbreviation of the complete URIref of the  resource being described. The fragment identifier  item10245 will be interpreted relative to a base  URI, in this case, the URI of the containing catalog  document. The full URIref for the tent is formed by taking the  base URI (of the catalog), and appending the character  "#" (to  indicate that what follows is a fragment identifier) and then  item10245 to it, giving the absolute URIref  http://www.example.com/2002/04/products#item10245.
  • it defines a name which must  be unique relative to the current base URI
  • Any other RDF/XML within this  catalog could refer to the tent by using either the absolute URIref  http://www.example.com/2002/04/products#item10245,   or the relative URIref #item10245
  • the URIref of the tent could also be given by specifying  rdf:about="#item10245" in the catalog entry (i.e., by  specifying the relative URIref directly) instead of  rdf:ID="item10245"
  • However, using rdf:ID provides an additional check  when assigning a set of distinct names
  • RDF located outside the catalog could refer to this  tent by using the full URIref
  • the effect of assigning URIrefs to  resources in RDF can be achieved by combining a process  (external to RDF) that identifies a single document (the  catalog in this case) as the source for descriptions of those  resources, with the use of relative URIrefs in descriptions of  those resources within that document.
  • basic  architectural principles of the Web, which is that   anyone  should be able to freely add information  about an existing resource, using any vocabulary they  please
  • relative URIrefs  such as #item10245 will be interpreted relative to a  base URI. By default, this base URI would be the URI  of the resource in which the relative URIref is used.  However, in some cases it is desirable to be able to explicitly  specify this base URI.
  • RDF/XML supports XML  Base [XML-BASE], which allows  an XML document to specify a base URI other than the URI of the  document itself.
  • xml:base="http://www.example.com/2002/04/products"
  • This idea of things being classified into different  kinds or categories is similar to the  programming language concept of objects having different  types or classes. RDF supports this concept  by providing a predefined property, rdf:type.
  • <rdf:type rdf:resource="http://www.example.com/terms/Tent"/>
  • If example.com had  described these classes as part of the product catalog itself,  the relative URIref #Tent could have been used to refer  to it.
  • Such resources are called typed nodes in the  graph, or typed node elements in the RDF/XML.
  • RDF/XML provides a special abbreviation for describing  these typed nodes.
  • <exterms:Tent rdf:ID="item10245">
  • Since a resource may be described as an instance of more   than one class, a resource may have more than one   rdf:type property.
  • • rdf:Bag
      
    • rdf:Seq
      
    • rdf:Alt
  • The members of the container can be  described by defining a container membership property
  • rdf:_n
  • t is important to understand that while these types of  containers are described using predefined RDF types and  properties, any special meanings associated with these  containers, e.g., that the members of an Alt container are  alternative values, are only intended meanings.
  • RDF/XML  provides rdf:li as a convenience element to avoid having  to explicitly number each membership property.
  • Since  no URIref is specified, the Bag is a blank node.
  • Alt containers are frequently used in conjunction with  language tagging. (RDF/XML permits the use of the xml:lang  attribute defined in [XML] to indicate  that the element content is in a specified language.
  • Sometimes there are clear alternatives to using these RDF  container types. For example, a relationship between a  particular resource and a group of other resources could be  indicated by making the first resource the subject of multiple  statements using the same property.
  • The choice  of which to use in a given situation should be made with this  in mind.

  • Consider as an example the relationship between a writer and  her publications, as in the sentence:

      

     

    Sue has written "Anthology of Time", "Zoological  Reasoning", and "Gravitational Reflections".

  • On the other hand, the sentence:

      

     

    The resolution was approved by the Rules Committee, having  members Fred, Wilma, and Dino.

     

      

    says that the committee as a whole approved the resolution;  it does not necessarily state that each committee member  individually voted in favor of the resolution
  • it is important to  understand that the statements are not constructing containers,  as in a programming language data structure. Instead,  the statements are describing containers (groups of things) that  presumably exist.
  • RDF imposes no "well-formedness" conditions on the use of   the container vocabulary
  • RDF applications that require containers  to be "well-formed" should be written to check that the  container vocabulary is being used appropriately, in order to  be fully robust.
  • A limitation of the containers described in Section 4.1 is that there is no way to  close them, i.e., to say "these are all the members of  the container".
  • RDF provides support for describing groups containing  only the specified members, in the form of RDF  collections.
  • properties rdf:first  and rdf:rest
  • type  rdf:List
  • resource  rdf:nil
  • each member of the collection, such as   s:Amy, is the object of an rdf:first property whose  subject is a resource (a blank node in this example) that  represents a list.   This list resource is linked to the rest of the list by an  rdf:rest property. The end of the list is indicated by  the rdf:rest property having as its object the resource  rdf:nil
  • Each of the blank nodes forming this list structure is   implicitly of type rdf:List  (that is, each of these nodes implicitly has an rdf:type property whose  value is the predefined type rdf:List),
  • The RDF Schema language [RDF-VOCABULARY]   defines the properties rdf:first and rdf:rest  as having subjects of type rdf:List, so the information about  these nodes being lists can generally be inferred, rather than the corresponding   rdf:type triples being written out all the time.
  • RDF/XML provides a special notation to make it easy to  describe collections
  • RDF/XML provides a special notation to make it easy to  describe collections using graphs of this form.
  • rdf:parseType="Collection"
  • RDF imposes no "well-formedness"   conditions on the use of the collection vocabulary
  • As a result, RDF applications that require collections  to be well-formed should be written to check that the  collection vocabulary is being used appropriately, in order to  be fully robust. In addition, languages such as   OWL [OWL],   which can define additional constraints on   the structure of RDF graphs, can rule out some of these cases.
  • RDF provides a built-in vocabulary intended for describing RDF statements.   A description of a statement using this vocabulary is called a   reification of the statement.
  • type  rdf:Statement, and the properties  rdf:subject, rdf:predicate, and  rdf:object.
  • care is needed in using it, because it  is easy to imagine that the vocabulary defines some things that are  not actually defined.
  • The conventional use of the RDF reification   vocabulary always involves describing a statement using four statements   in this pattern; the four statements are sometimes referred to as a   "reification quad" for this reason.
  • exproducts:triple12345 dc:creator exstaff:85740 .
  • rdf:ID can also be used in a   property element to automatically produce a reification of the triple that   the property element generates
  • rdf:ID="triple12345"
  • care is needed when using  the RDF reification vocabulary
  • conventions
  • assumptions
  • The lack of a built-in means for assigning URIrefs to   statements does not mean that "provenance" information   of this kind cannot  be expressed in RDF, just that it cannot be done using only the  meaning RDF associates with the reification vocabulary.
  • For  example, if an RDF document (say, a Web page) has a URI,  statements could be made about the resource identified by that URI  and, based on some application-dependent understanding of how  those statements should be interpreted, an application could act as if those  statements "distribute" over (apply equally to) all the  statements in the document. Also, if some mechanism exists  (outside of RDF) to assign URIs to individual RDF statements,  then statements could certainly be made about those individual  statements, using their URIs to identify them. However, in these cases,  it would also not be strictly necessary to use the reification vocabulary  in the conventional way.
  • in some cases one of  the parts of the structured value is often thought of as the  "main" value, with the other parts of the relation providing  additional contextual or other information that qualifies the  main value.
  • In the RDF model a qualified property value of this kind can be  considered as simply another kind of structured value.
  • RDF provides a predefined rdf:value property to describe  the main value (if there is one) of a structured value.
  • rdf:parseType="Resource"
  • rdf:value
  • An   rdf:parseType="Resource" attribute is used to indicate   that the contents of an element are to be interpreted as the description   of a new (blank node) resource, without actually having to write a   nested rdf:Description element. In this case, the   rdf:parseType="Resource" attribute used in the   exterms:weight property element indicates that a   blank node is to be created as the value of the exterms:weight   property, and that the enclosed elements (rdf:value and   exterms:units) describe properties of that blank node.
  • There is no need to use rdf:value for these purposes  (
  • rdf:value is simply provided as a convenience for use in these  commonly-occurring situations.
  • Sometimes the value of a property needs to be a fragment of XML,   or text that might contain XML markup.
  • Giving an element the attribute  rdf:parseType="Literal" indicates that the contents of   the element are to be interpreted as an XML fragment.
  • rdf:parseType="Literal"
  • Contextual attributes, such as xml:lang and xml:base  are not inherited from the RDF/XML document, and, if required, must,   as shown in the example, be explicitly specified in the XML fragment.
  • RDF user  communities also need the ability     to define the vocabularies  (terms) they intend to use in those statements, specifically,     to indicate that they are  describing specific kinds or classes of resources, and will use  specific properties in describing those resources.
  • such classes and properties are described as an RDF  vocabulary, using extensions to RDF provided by the RDF Vocabulary  Description Language 1.0: RDF Schema [RDF-VOCABULARY], referred  to here as RDF Schema.
  • it provides the facilities needed  to describe such classes and properties,   and to indicate which classes and properties are  expected to be used together
  • RDF Schema provides a  type system for RDF
  • RDF Schema  allows resources to be defined as instances of one or more  classes. In addition, it allows classes to be organized  in a hierarchical fashion;
  • RDF  class and property descriptions do not create a straightjacket  into which information must be forced
  • rdfs:
  • A  class in RDF Schema corresponds to the generic concept  of a Type or Category, somewhat like the  notion of a class in object-oriented programming languages such  as Java.
  • rdfs:Resource
  • rdfs:subClassOf
  • rdf:type
  • rdfs:Class
  • The resources that belong to  a class are called its instances.
  • rdf:type rdfs:Class
  • rdf:type ex:MotorVehicle
  • a common convention that class names  are written with an initial uppercase letter, while property  and instance names are written with an initial lowercase  letter
  • eparate vocabularies for classes of things, and  instances of things
  • rdfs:subClassOf ex:MotorVehicle
  • RDF software written to understand the RDF Schema vocabulary  can infer the additional information   that exthings:companyVan   is also an instance of ex:MotorVehicle
  • RDF itself does not define the special   meaning of terms from the RDF Schema vocabulary such as rdfs:subClassOf.
  • The rdfs:subClassOf property is  transitive.
  • A class may be a subclass of more than  one class (for example, ex:MiniVan may be a subclass  of both ex:Van and ex:PassengerVehicle).
  • RDF Schema defines  both the subjects and objects of statements that use the   rdfs:subClassOf property to be resources of type  rdfs:Class
  • xml:base="http://example.org/schemas/vehicles">
  • rdf:ID is useful here because  it both abbreviates the URIrefs, and also provides an additional   check that the value of the rdf:ID attribute is  unique against the current base URI
  • Relative  URIrefs based on these names can then be used in other class  definitions within the same schema (e.g., as   #MotorVehicle is used in the description of the other  classes).
  • xmlns:ex="http://example.org/schemas/vehicles#"
  • In addition to describing the specific classes of  things they want to describe, user communities also need to be  able to describe specific properties that characterize  those classes of things
  • RDF Schema properties rdfs:domain,  rdfs:range, and rdfs:subPropertyOf
  • RDF class rdf:Property
  • rdf:type rdf:Property
  • RDF Schema also provides vocabulary for describing how  properties and classes are intended to be used together in RDF  data.
  • The rdfs:range property is used to indicate that  the values of a particular property are instances of a  designated class.
  • rdfs:range ex:Person
  • If ex:hasMother has more than one  range property, say one specifying ex:Person as its  range, and another specifying ex:Female as its range,  this says that the values of the ex:hasMother property  are resources that are instances of all of the classes  specified as the ranges, i.e., that any value of  ex:hasMother is both a ex:Female  and a ex:Person.
  • The rdfs:range property can also be used to  indicate that the value of a property is given by a typed  literal
  • rdfs:range xsd:integer
  • it is often useful to  explicitly state that a given URIref identifies a datatype.  This can be done using the RDF Schema class  rdfs:Datatype.
  • rdf:type rdfs:Datatype
  • The rdfs:domain property is used to indicate that a  particular property applies to a designated class.
  • rdfs:domain ex:Book
  • RDF  statements using the ex:author property have instances  of ex:Book as subjects.
  • If  exterms:weight has more than one domain property, say  one specifying ex:Book as the domain and another one  specifying ex:MotorVehicle as the domain, this says  that any resource that has a exterms:weight property  is an instance of all of the classes specified as the  domains, i.e., that any resource that has a  exterms:weight property is both a ex:Book  and a ex:MotorVehicle (illustrating the need  for care in specifying domains and ranges).
  • RDF Schema provides a way to specialize properties  as well as classes. This specialization  relationship between two properties is described using the predefined  rdfs:subPropertyOf property.
  • rdfs:subPropertyOf ex:driver
  • The meaning of this rdfs:subPropertyOf relationship  is that if an instance exstaff:fred is an  ex:primaryDriver of the instance  ex:companyVan, then   RDF Schema defines exstaff:fred as also being  an ex:driver of  ex:companyVan.
  • A property may be a subproperty of zero, one or more  properties.
  • All RDF Schema rdfs:range and  rdfs:domain properties that apply to an RDF property  also apply to each of its subproperties.
  • In RDF, on the other hand, property  descriptions are, by default, independent of class  definitions, and have, by default, global scope
  • Another result of the global scope of RDF property descriptions  is that it is not possible in an RDF schema to define a specific property as  having locally-different ranges depending on the class of the resource  it is applied to.   For example
  • However, while  such locally-different ranges cannot be defined in RDF Schema,  they can be defined in some of the richer schema languages discussed in   Section 5.5.
  • Another important difference is that RDF Schema descriptions  are not necessarily prescriptive in the way  programming language type declarations typically are.

  • For  example, if a programming language declares a class  Book with an author attribute having values  of type Person, this is usually interpreted as a group  of constraints. The language will not allow the  creation of an instance of Book without an  author attribute, and it will not allow an instance of  Book with an author attribute that does not  have a Person as its value. Moreover, if  author is the only attribute defined for  class Book, the language will not allow an instance of  Book with some other attribute.

      

    RDF Schema, on the other hand, provides schema information  as additional descriptions of resources, but does not  prescribe how these descriptions should be used by an  application. For example, suppose an RDF schema states that an  ex:author property has an rdfs:range of class  ex:Person. This is simply an RDF statement that RDF  statements containing ex:author properties have  instances of ex:Person as objects.
  • One application might interpret this statement as  specifying part of a template for RDF data it is creating, and  use it to ensure that any ex:author property has a  value of the indicated (ex:Person) class. That is,  this application interprets the schema description as a  constraint in the same way that a programming language  might. However, another application might interpret this  statement as providing additional information about data it is  receiving, information which may not be provided explicitly in  the original data. For example, this second application might  receive some RDF data that includes an ex:author  property whose value is a resource of unspecified class, and  use this schema-provided statement to conclude that the  resource must be an instance of class ex:Person. A  third application might receive some RDF data that includes an  ex:author property whose value is a resource of class  ex:Corporation, and use this schema information as the  basis of a warning that "there may be an inconsistency here,  but on the other hand there may not be". Somewhere else there  may be a declaration that resolves the apparent inconsistency  (e.g., a declaration to the effect that "a Corporation is a  (legal) Person").
  • In other words, statements in an RDF schema are always  descriptions
  • the  rdfs:comment property can be used to provide a  human-readable description of a resource.
  • rdfs:label property
  • rdfs:comment
  • rdfs:comment property
  • rdfs:seeAlso property
  • rdfs:isDefinedBy property

  • RDF Schema provides basic capabilities for describing RDF  vocabularies, but additional capabilities are also possible,  and can be useful. These capabilities may be provided through  further development of RDF Schema, or in other languages based  on RDF. Other  richer schema capabilities that have been identified as useful  (but that are not provided by RDF Schema) include:

      
     
    • cardinality constraints on properties, e.g.,  that a Person has exactly one biological  father.
      
    • specifying that a given property (such as  ex:hasAncestor) is transitive, e.g., that if A  ex:hasAncestor B, and B ex:hasAncestor C, then A  ex:hasAncestor C.
      
    • specifying that a given property is a unique identifier  (or key) for instances of a particular class.
      
    • specifying that two different classes (having different  URIrefs) actually represent the same class.
      
    • specifying that two different instances (having different  URIrefs) actually represent the same individual.
      
    • specifying constraints on the range or cardinality  of a property that depend on the class of resource  to which a property is applied, e.g., being able to  say that for a soccer team the ex:hasPlayers  property has 11 values, while for a basketball team  the same property should have only 5 values.
      
    • the ability to describe new classes in terms of  combinations (e.g., unions and intersections) of other  classes, or to say that two classes are disjoint (i.e., that  no resource is an instance of both classes).
     
      

    The additional capabilities mentioned above, in addition to  others, are the targets of ontology languages such as  DAML+OIL  [DAML+OIL] and OWL [OWL].
  • The Dublin Core is a set of "elements" (properties) for  describing documents (and hence, for recording metadata).
  • The Dublin Core metadata set is intended to be  suitable for use by resource discovery tools on the Internet,  such as the "Webcrawlers" employed by popular World Wide Web  search engines. In addition, the Dublin Core is meant to be  sufficiently simple to be understood and used by the wide range  of authors and casual publishers who contribute information to  the Internet. Dublin Core elements have become widely used in  documenting Internet resources
  • Also, as a matter of interest,   accessing http://purl.org/dc/elements/1.1/  (the namespace URI used to identify the Dublin Core vocabulary in this  example)  in a Web browser (as of the current writing) will retrieve an  RDF Schema declaration for [DC].
  • omputer languages and file formats do  not always make explicit provision for   embedding metadata with the  data it describes. In many cases, the metadata has to be specified   as a separate resource and explicitly linked to the data
  • However, applications and languages are increasingly making explicit   provision for embedding metadata directly with the data. For example, the  W3C's Scalable Vector Graphics language   [SVG] (another XML-based language)   provides an explicit metadata element for recording metadata  along with other SVG data.
  • PRISM:  Publishing Requirements for Industry Standard Metadata [PRISM] is a metadata specification  developed in the publishing industry. Magazine publishers and  their vendors formed the PRISM Working Group to  identify the industry's needs for metadata and define a  specification to meet them. Publishers want to use existing  content in many ways in order to get a greater return on the  investment made in creating it. Converting magazine articles to  HTML for posting on the Web is one example. Licensing it to  aggregators like LexisNexis   is another. All of these are "first  uses" of the content; typically they all go live at the time  the magazine hits the stands. The publishers also want their  content to be "evergreen". It might be used in new issues, such  as in a retrospective article. It could be used by other  divisions in the company, such as in a book compiled from the  magazine's photos, recipes, etc. Another use is to license it  to outsiders, such as in a reprint of a product review, or in a  retrospective produced by a different publisher. This overall  goal requires a metadata approach that emphasizes  discovery, rights tracking, and  end-to-end metadata.
  • To assist discovery, PRISM provides properties to describe  the topics, formats, genre, origin, and contexts of a resource.  It also provides means for categorizing resources using  multiple subject description taxonomies.
  • PRISM provides elements for basic tracking of  such rights. A separate vocabulary defined in the  PRISM specification supports description of places, times, and  industries where content may or may not be used.
  • An important feature of the PRISM  specification is its use of other existing specifications.  Rather than create an entirely new thing, the group decided to  use existing specifications as much as possible, and only  define new things where needed. For this reason, the PRISM  specification uses XML, RDF, Dublin Core, and well as various  ISO formats and vocabularies.
  • PRISM also augments the Dublin Core to allow more detailed  descriptions. The augmentations are defined as three new  vocabularies, generally cited using the prefixes prism:,  pcv:, and prl:.
  • Best  practice is to code the articles with subject terms from a  "controlled vocabulary". The vocabulary should provide as many  synonyms as possible for its terms in the vocabulary.
  • No one person or organization controls who makes URIs or how  they can be used.
  • People  sometimes use RDF together with a convention that, when a URIref  is used to identify an RDF resource, a page containing  descriptive information about that resource will be placed on the  Web "at" that URI

  228 more annotations...

• 05 Feb 12
  

  ask4amit
  • Literals may not be used as subjects or  predicates in RDF statements
  • In drawing RDF  graphs, nodes that are URIrefs are shown as ellipses,   while nodes that are literals are shown as boxes.
• 30 Jan 12
  

  Sub Proletarian

  rdf w3c

• 19 Jan 12
  

  Kai Michael Höver

  semanticweb w3c rdf rdfs

• 12 Sep 11
  

  Leoben Conoy

  work ibm rdf xml primer documentation specifications semanticweb w3c resource description language

• 24 Jul 11
  

  Alistair Young

  rdf

• 12 Jul 11
  

  Phelim Bradley

  This is what User:Phelimb thinks of this glossary item. Although he accepts that it is the "same as" the Primary Glossary item his format etc differs in some way. User may also differ in which url best describes the data. Any user may add [[www.phel.im|ex

  uniqueID:RDF item_license:CC-BY-NC-SA item_from_www.dlib.indiana.edu_~jenlrile_ glossary_item delicious

• 05 Jul 11
  

  Neil Hambleton

  semanticweb semantic

• 09 May 11
  

  Patrik Malmberg
  • representing inf
• 20 Apr 11
  

  Alex K

  rdf w3c xml semanticweb metadata reference semantic

  • This Primer is designed to provide the reader with the basic  knowledge required to effectively use RDF.
  • The Resource Description Framework (RDF) is a language for  representing information about resources in the World Wide Web.  It is particularly intended for representing metadata about Web  resources, such as the title, author, and modification date of a  Web page, copyright and licensing information about a Web  document, or the availability schedule for some shared resource.
  • RDF is intended for situations in which this information   needs to be processed by applications, rather than being   only displayed to people.

  • This Primer is intended to provide an introduction to RDF and  describe some existing RDF applications, to help information  system designers and application developers understand the  features of RDF and how to use them. In particular, the Primer is  intended to answer such questions as:

      
     
    • What does RDF look like?
      
    • What information can RDF represent?
      
    • How is RDF information created, accessed, and  processed?
      
    • How can existing information be combined with RDF?
  • RDF is about making  machine-processable statements.
  • a system of machine-processable identifiers   for identifying a subject, predicate, or object in a statement  without any possibility of confusion
  • a machine-processable language
  • The Web provides a more general form of identifier for these  purposes, called the Uniform Resource  Identifier (URI). URLs are a particular kind of URI.
  • RDF uses URIs as the basis of  its mechanism for identifying the subjects, predicates, and  objects in statements.
  • To be more precise, RDF uses URI  references [URIS]. A URI reference  (or URIref) is a URI, together with an optional  fragment identifier at the end. For example, the URI  reference http://www.example.org/index.html#section2  consists of the URI http://www.example.org/index.html  and (separated by the "#" character) the fragment identifier  Section2.
  • To represent RDF statements in a machine-processable way,  RDF uses the Extensible  Markup Language [XML].
  • In drawing RDF  graphs, nodes that are URIrefs are shown as ellipses,   while nodes that are literals are shown as boxes.

  10 more annotations...

• 08 Dec 10
  

  Sarab Pannu

  semantic_web rdf

• 04 Dec 10
  

  Adriana Farina

  rdf

• 03 Dec 10
  

  kardeiz
  • • classes are disjoint (i.e., that  no resource is an instance of both classes).
     
      
    The additional capabilities mentioned above, in addition to  others, are the targets of ontology languages such as  DAML+OIL  [DAML+OIL] and OWL [OWL]. Both these languages are based on  RDF and RDF Schema (and both currently provide all the  additional capabilities mentioned above). The intent of such  languages is to provide additional machine-processable  semantics for resources, that is, to make the machine  representations of resources more closely resemble their  intended real world counterparts. While such capabilities are  not necessarily needed to build useful applications using RDF  (see Section 6 for a description of  a number of existing RDF applications), the development of such  languages is a very active subject of work as part of the  development of the Semantic Web.
     
     
      
     

    6. Some RDF  Applications: RDF in the Field
• 27 Nov 10
  

  rdf semanticweb reference w3c

• 11 Nov 10
  

  Janos Haits

  Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic concepts of RDF and describes its XML syntax. It describes how to define RDF vocabularies using the RDF Vocabulary Description Language, and gives an overview of some deployed RDF applications. It also describes the content and purpose of other RDF specification documents.

  rdf primer w3c semanticweb metadata semantic xml web3.0 semweb web

• 08 Sep 10
  

  Peter Simonetti

  SOA Specification w3c RDF semanticweb xml

• 14 Jul 10
  

  Timo Tuominen

  rdf semanticweb tutorial top

• 17 Jun 10
  

  Steven Tatum

  Explanation of rdf

  semantic_web metadata tutorials rdf

• 14 Jun 10
  

  Mace Ojala

  metadata w3c tutorial semanticweb semantic xml primer rdf elag2010

• 19 May 10
  

  Alain Marois

  w3c metadata xml rdf **** documentation

  • 4.1 RDF  Containers
  • A Bag (a resource having type rdf:Bag)
  • where there is no significance in the order of the  members.
  • Sequence or Seq
  • where the order of the members is  significant.
  • Alternative or Alt
  • a group of resources or literals that  are alternatives (typically for a single value of a  property)
  • The element name rdf:li was chosen to  be mnemonic with the term "list item" from HTML

  6 more annotations...

• 05 May 10
  

  David Chapman

  semanticweb semantic web2.0 xml rdf tutorial TU100

• 20 Apr 10
  

  Katrin Köhler

  rdf w3c xml semanticweb primer

  • prefix rdf:, namespace URI:  http://www.w3.org/1999/02/22-rdf-syntax-ns#
      prefix rdfs:, namespace URI:  http://www.w3.org/2000/01/rdf-schema#
      prefix dc:, namespace URI:  http://purl.org/dc/elements/1.1/
      prefix owl:, namespace URI:  http://www.w3.org/2002/07/owl#
      prefix ex:, namespace URI:  http://www.example.org/ (or  http://www.example.com/)
      prefix xsd:, namespace URI:  http://www.w3.org/2001/XMLSchema#

      

    Obvious variations on the "example" prefix  ex: will also be used as needed in the examples, for instance,
     
      prefix exterms:, namespace URI:  http://www.example.org/terms/ (for terms used by an  example organization),
      prefix exstaff:, namespace URI:  http://www.example.org/staffid/ (for the example  organization's staff identifiers),
      prefix ex2:, namespace URI:  http://www.domain2.example.org/ (for a second example  organization), and so on.
• 08 Feb 10
  

  nathandh_2000

  semanticweb rdf

• 04 Jan 10
  

  Mitch DeFelice

  Websites Standards

• 24 Nov 09
  

  rdf semanticweb w3c xml reference web semantic tutorial for:ingrid.segura

• 12 Nov 09
  

  David Clay

  RDF W3C

• 12 Oct 09
  

  Sam Lester

  reference article documentation web programming aggregator semantic-web tagging rss web2.0 webdev metadata semanticweb taxonomy standards howto research xml development tutorial semantic w3c tutorials rdf ontology semantic_web specification primer semweb

• 24 Sep 09
  

  Laurie Lee Moses

  LEEP12.1 ROL

• 10 Aug 09
  

  Thieme Hennis

  RDF primer: introduction to the semantic web and the RDF standard for web resources.

  rdf xml metadata semantic-web semantic

  • The Resource Description Framework (RDF) is a language for  representing information about resources in the World Wide Web.  It is particularly intended for representing metadata about Web  resources, such as the title, author, and modification date of a  Web page, copyright and licensing information about a Web  document, or the availability schedule for some shared resource.
  • RDF is intended for situations in which this information   needs to be processed by applications, rather than being   only displayed to people.    RDF provides a common framework for expressing this  information so it can be exchanged between applications without  loss of meaning. Since it is a common framework, application  designers can leverage the availability of common RDF parsers and  processing tools. The ability to exchange information between  different applications means that the information may be made  available to applications other than those for which it was  originally created.
• 03 Aug 09
  

  roguepuppet

  rdf w3c tutorials

• 29 May 09
  

  Michael van Vliet

  rdf w3c semanticweb metadata

• 24 May 09
  

  usingsystem

  rdf semantic semanticweb web xml article tutorial w3c reference

• 19 May 09
  

  Swarna Srinivasan

  RDF semantic

• 08 Apr 09
  

  Leonardo Oliveira

  web semântica w3c rdf semanticweb xml web3.0

• 07 Apr 09
  

  Joe Nicholls

  The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic conc

  semanticweb rdf reference semantic tutorial

• 03 Apr 09
  

  Ben Ranker

  rdf-primer rdf semantic-web

• 01 Apr 09
  

  Kathryn .

  rdf 537

• 25 Mar 09
  

  Marcel Knust
• 13 Mar 09
  

  devrimbaris

  w3c rdf rdfs

• 09 Feb 09
  

  robert bale

  reference xml metadata ontology rdf w3c semantic

• 05 Feb 09
  

  Lee Anne Pedersen

  rdf semantic standards web semantic web

• 29 Dec 08
  

  Javier Neira

  reference semanticweb w3c rdf

• 09 Dec 08
  

  shingo nakayama
  • predicate
• 04 Nov 08
  

  Shoaib Sufi

  rdf toread obesity-e-lab

• 18 Oct 08
  

  Eisenham Wong
  • 
  • Since RDF uses URIrefs instead of words to name things in statements, RDF refers to a set of URIrefs (particularly a set intended for a specific purpose) as a vocabulary.
  • Using common URI prefixes provides a convenient way to organize the URIrefs for a related set of terms. However, this is just a convention. The RDF model only recognizes full URIrefs; it does not "look inside" URIrefs or use any knowledge about their structure. In particular, RDF does not assume there is any relationship between URIrefs just because they have a common leading prefix (see Appendix A for further discussion). Moreover, there is nothing that says that URIrefs with different leading prefixes cannot be considered part of the same vocabulary. A particular organization, process, tool, etc. can define a vocabulary that is significant for it, using URIrefs from any number of other vocabularies as part of its vocabulary.
  • URIrefs from different vocabularies can be freely mixed in RDF graphs.
  • Also, RDF imposes no restrictions on how many statements using a given URIref as predicate can appear in a graph to describe the same resource.
  • An advantage of  using a URIref in this case is that the identification  of the statement's subject can be more precise.   That is, the creator of the page is not the  character string "John Smith", or any one of the thousands of  people named John Smith, but the particular John Smith  associated with that URIref (whoever created the URIref defines  the association). Moreover, since there is a URIref to refer to  John Smith, he is a full-fledged resource, and   additional information can be recorded about him, simply by adding  additional RDF statements with John's URIref as the subject.
  • Using URIrefs to  identify properties is important for a number of reasons.  First, it distinguishes the properties one person may use from  different properties someone else may use that would otherwise be  identified by the same character string.
  • Also, using URIrefs to identify properties   enables the properties to be treated as resources themselves.  Since properties are resources, additional  information can be recorded about them (e.g., the English description of what  example.org means by "name"), simply by adding additional RDF  statements with the property's URIref as the subject.
  • Using URIrefs as subjects, predicates, and objects in RDF  statements supports the development and use of shared  vocabularies on the Web, since people can discover and begin using   vocabularies already used by others to describe things, reflecting   a shared understanding of those concepts.
  • Structured information like this is represented in RDF by  considering the aggregate thing to be described (like  John Smith's address) as a resource, and then making statements  about that new resource. So, in the RDF graph, in order to  break up John Smith's address into its component parts,   a new node is created to represent the concept of John Smith's  address, with a new URIref to identify it,  say http://www.example.org/addressid/85740   (abbreviated as exaddressid:85740).   RDF statements (additional arcs and nodes) can then be  written with that  node as the subject, to represent the additional information,  producing the graph shown in Figure  5:
  • 
  • This way of representing structured information in RDF can   involve generating numerous "intermediate" URIrefs   such as exaddressid:85740 to represent aggregate concepts such as  John's address. Such concepts may never need to be referred to  directly from outside a particular graph, and hence may not  require "universal" identifiers. In addition, in the  drawing of the graph representing the group of  statements shown in Figure 5,   the URIref assigned to identify "John Smith's  address" is not really needed, since the graph could just as easily   have been drawn as in Figure 6:
  • 
  • This blank  node serves its purpose in the drawing without needing a  URIref, since the node itself provides the necessary  connectivity between the various other parts of the graph.  (Blank nodes were called anonymous resources in [RDF-MS].)
  • However, some  form of explicit identifier for that node is needed in order to  represent this graph as triples.
  • Since a complex graph might contain more  than one blank node, there also needs to be a way to differentiate  between these different blank nodes in a triples representation  of the graph.
  • As a result, triples use blank  node identifiers, having the form _:name, to  indicate the presence of blank nodes.
  • In a triples representation of a graph, each distinct blank  node in the graph is given a different blank node identifier.  Unlike URIrefs and literals, blank node identifiers are not  considered to be actual parts of the RDF graph
  • Blank node identifiers are just a way of  representing the blank nodes in a graph (and distinguishing one  blank node from another) when the graph is written in triple  form. Blank node identifiers also have significance only within  the triples representing a single graph (two different  graphs with the same number of blank nodes might independently  use the same blank node identifiers to distinguish them, and it  would be incorrect to assume that blank nodes from different  graphs having the same blank node identifiers are the same).
  • Finally, because blank node identifiers represent  (blank) nodes, rather than arcs, in the triple form of  an RDF graph, blank node identifiers may only appear as subjects or  objects in triples; blank node identifiers may not be used as  predicates in triples.
  • important aspect of RDF: RDF  directly represents only binary relationships
  • For each n-ary relationship,  one of the participants is chosen as the subject of the  relationship (John in this case), and a blank node is created to  represent the rest of the relationship (John's address in this  case). The remaining participants in the  relationship (such as the city in this example) are then  represented as separate  properties of the new resource represented by the blank  node.
  • Blank nodes also provide a way to more accurately make  statements about resources that may not have URIs, but that are  described in terms of relationships with other resources that  do have URIs.
  • (Note that mailto:jane@example.org  is written within angle brackets in the first triple. This is because   mailto:jane@example.org is a full URIref in the  mailto URI scheme, rather than a QName abbreviation,  and full URIrefs must be enclosed in angle brackets in the triples  notation.)
  • That is, the blank node can be read as "there  is a resource". Statements with that blank node as subject then  provide information about the characteristics of that  resource.
  • Incidentally, some  RDF-based schema languages allow specifying that certain  properties are unique identifiers of the resources they  describe.
  • Using blank nodes in this way can also help avoid the use of  literals in what might be inappropriate situations.
  • Such information is often omitted in contexts where it can be safely assumed that anyone accessing the property value will understand the units being used. However, in the wider context of the Web, it is generally not safe to make this assumption.
  • In general, careful consideration should be given to explicitly representing units and similar information.

  • In RDF,  typed  literals are used to provide this kind of information.

       

    An RDF typed literal is formed by pairing a string  with a URIref that identifies a particular datatype. This  results in a single literal node in the RDF graph with the pair as the literal.  The value represented by the typed literal is the value that   the specified datatype associates with the specified string.   For example, using a typed literal, John Smith's age could be described as  being the integer number 27 using the triple:

      

     

    <http://www.example.org/staffid/85740>  <http://www.example.org/terms/age> "27"^^<http://www.w3.org/2001/XMLSchema#integer> . 

     

      

    or, using the QName simplification for writing long  URIs:

      

     

    exstaff:85740  exterms:age  "27"^^xsd:integer . 

     

      

    or as shown in Figure 8:

      

     
  • 
  • Unlike typical programming languages and database systems,  RDF has no built-in set of datatypes of its own, such as  datatypes for integers, reals, strings, or dates.   Instead,  RDF typed literals simply provide a way to explicitly  indicate, for a given literal, what datatype should be used to  interpret it. The datatypes used in typed literals are defined   externally to RDF, and identified by their datatype  URIs.
  • An advantage of this approach is that it  gives RDF the flexibility to directly represent information  coming from different sources without the need to perform type  conversions between these sources and a native set of RDF  datatypes. (Type conversions would still be required when  moving information between systems having different sets of datatypes,  but RDF would impose no extra conversions into and out  of a native set of RDF datatypes.)
  • Not all datatypes are suitable for use in RDF. For a datatype   to be suitable for use in RDF, it  must conform to the conceptual framework just described. This basically means  that, given a character string, the datatype must   unambiguously define   whether or not the string is in its lexical space, and  what value in its value space the string represents.
  • Since the value that a given typed literal denotes is defined  by the typed literal's datatype, and, with the exception of   rdf:XMLLiteral, RDF does not define any datatypes,  the actual interpretation of a   typed literal appearing in an RDF graph (e.g., determining  the value it denotes) must be performed by software  that is written to correctly process not only RDF, but the  typed literal's datatype as well. Effectively, this software must  be written to process an extended language that includes not  only RDF, but also the datatype, as part of its built-in  vocabulary.  This raises the issue of which datatypes will be generally available in  RDF software.   Generally, the XML Schema datatypes that are listed as suitable   for use in RDF in [RDF-SEMANTICS]     have a "first among equals" status in RDF.
  • In general, RDF software may be called on to process RDF  data that contains references to datatypes that the software   has not been written to  process, in which case there are some things the software  will not be able to do.     For one thing, with the exception of rdf:XMLLiteral,  RDF itself does not define the URIrefs that identify datatypes.  As a result, RDF software, unless it has been written to recognize specific  URIrefs, will not be able to determine whether or not  a URIref written in a typed literal actually identifies a datatype.  Moreover, even when a URIref does identify a datatype, RDF  itself does not define the validity of pairing that datatype  with a particular literal. This validity can only be determined  by software written to correctly process that particular datatype.
  • A  blank node identifier serves to identify a blank node within a  particular RDF/XML document but, unlike a URIref, is unknown  outside the document in which it is assigned. A blank node is  referred to in RDF/XML using an rdf:nodeID attribute,  with a blank node identifier as its value, in places where the  URIref of a resource would otherwise appear. Specifically,  a statement with a blank node as its subject can be written in  RDF/XML using an rdf:Description element with  an rdf:nodeID attribute instead of an  rdf:about attribute. Similarly, a statement with a  blank node as its object can be written using a property  element with an rdf:nodeID attribute instead of an  rdf:resource attribute.
  • Example 6: RDF/XML  Describing a Blank Node 

      

     

    1.  <?xml version="1.0"?> 2.  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 3.              xmlns:dc="http://purl.org/dc/elements/1.1/" 4.              xmlns:exterms="http://example.org/stuff/1.0/">  5.     <rdf:Description rdf:about="http://www.w3.org/TR/rdf-syntax-grammar"> 6.       <dc:title>RDF/XML Syntax Specification (Revised)</dc:title> 7.       <exterms:editor rdf:nodeID="abc"/> 8.     </rdf:Description>  9.     <rdf:Description rdf:nodeID="abc"> 10.        <exterms:fullName>Dave Beckett</exterms:fullName> 11.        <exterms:homePage rdf:resource="http://purl.org/net/dajobe/"/> 12.    </rdf:Description>  13. </rdf:RDF> 
  • using a blank node identifier allows the same blank node to be  referred to in more than one place in the same RDF/XML  document
  • A typed literal is represented in RDF/XML by  adding an rdf:datatype attribute specifying a datatype  URIref to the property element containing the literal.
  • In RDF/XML, both plain and typed literals (and, with certain exceptions, tags) can contain Unicode [UNICODE] characters, allowing information from many languages to be directly represented.
  • XML entities can be used in RDF/XML to improve readability   in such cases, by providing an additional abbreviation   facility for URIrefs. Essentially, an XML entity declaration   associates a name with a string of characters. When the entity   name is referenced elsewhere within an XML document, XML processors replace   the reference with the corresponding string.
  • Although RDF does not specify or control how URIrefs are  assigned to resources, sometimes it is desirable to achieve the  effect of assigning URIrefs to resources that are part  of an organized group of resources.
  • Using rdf:ID specifies  a fragment identifier, given by the  value of the rdf:ID attribute (item10245 in  this case, which might be the catalog number assigned by  example.com), as an abbreviation of the complete URIref of the  resource being described. The fragment identifier  item10245 will be interpreted relative to a base  URI, in this case, the URI of the containing catalog  document. The full URIref for the tent is formed by taking the  base URI (of the catalog), and appending the character  "#" (to  indicate that what follows is a fragment identifier) and then  item10245 to it, giving the absolute URIref  http://www.example.com/2002/04/products#item10245.
  • The rdf:ID attribute is somewhat similar to the ID  attribute in XML and HTML, in that it defines a name which must  be unique relative to the current base URI (in this example, that of the catalog).   In this case, the rdf:ID  attribute appears to be assigning a name (item10245)  to this particular kind of tent. Any other RDF/XML within this  catalog could refer to the tent by using either the absolute URIref  http://www.example.com/2002/04/products#item10245,   or the relative URIref #item10245. The  relative URIref would be understood as being a URIref defined relative to the  base URIref of the catalog. Using a similar abbreviation,   the URIref of the tent could also be given by specifying  rdf:about="#item10245" in the catalog entry (i.e., by  specifying the relative URIref directly) instead of  rdf:ID="item10245" . As an abbreviation mechanism,   the two forms are essentially  synonyms: the full URIref formed by RDF/XML is the same in  either case:  http://www.example.com/2002/04/products#item10245.   However, using rdf:ID provides an additional check  when assigning a set of distinct names, since a given value of the  rdf:ID attribute can only appear once relative to the  same base URI (the catalog document, in this example). Using  either form, example.com would be giving the URIref for the  tent in a two-stage process, first assigning the URIref for the  whole catalog, and then using a relative URIref in the  description of the tent in the catalog to indicate the URIref  that has been assigned to this particular kind of tent.  Moreover, this use of a relative URIref can be thought of either   as being an abbreviation for a full URIref that has been  assigned to the tent independently of the RDF, or as being the  assignment of the URIref to the tent within the catalog.
  • First, even though  RDF does not specify or control how URIrefs are assigned to  resources (in this case, the various tents and other items in  the catalog), the effect of assigning URIrefs to  resources in RDF can be achieved by combining a process  (external to RDF) that identifies a single document (the  catalog in this case) as the source for descriptions of those  resources, with the use of relative URIrefs in descriptions of  those resources within that document.
  • Note that RDF does not assume any  particular relationship exists between two resources just  because their URIrefs have the same base, or are otherwise  similar. This relationship may be known to example.com, but it  is not directly defined by RDF.
  • anyone  should be able to freely add information  about an existing resource, using any vocabulary they  please
  • the RDF describing a particular  resource does not need to be located all in one place; instead,  it may be distributed throughout the Web. This is true not only  for situations like this one, in which one organization is  rating or commenting on a resource defined by another, but also  for situations in which the original definer of a resource (or  anyone else) wishes to amplify the description of that resource  by providing additional information about it. This may be done  by modifying the RDF document in which the resource was  originally described, to add the properties and values needed  to describe the additional information. Or, as this example  illustrates, a separate document could be created, providing the  additional properties and values in rdf:Description  elements that refer to the original resource via its URIref  using rdf:about.
  • However, in some cases it is desirable to be able to explicitly  specify this base URI.
  • To deal with such cases, RDF/XML supports XML  Base [XML-BASE], which allows  an XML document to specify a base URI other than the URI of the  document itself.
  • xml:base="http://www.example.com/2002/04/products"
  • When an  RDF resource is described with an rdf:type property,  the value of that property is considered to be a resource that  represents a category or class of things, and the  subject of that property is considered to be an  instance of that category or class.
  • It is fairly common in RDF for resources to have rdf:type  properties that describe the resources as instances of specific types  or classes. Such resources are called typed nodes in the  graph, or typed node elements in the RDF/XML
  • RDF/XML provides a special abbreviation for describing  these typed nodes. In this abbreviation, the  rdf:type property and its value are removed, and the  rdf:Description element for the node is replaced by an element  whose name is the QName corresponding to the value of the  removed rdf:type property (a URIref that names a class).
  • Since a resource may be described as an instance of more   than one class, a resource may have more than one   rdf:type property. However, only one of these   rdf:type properties can be abbreviated in this way.   The others must be written out using rdf:type properties,   in the manner illustrated by the  rdf:type property in Example 12.
  • In addition to its use in describing instances of user-defined  classes such as exterms:Tent, the typed node abbreviation   is also commonly used in RDF/XML when describing instances of   the built-in RDF classes (such as rdf:Bag) to be  described in Section 4, and  the built-in RDF Schema classes (such as rdfs:Class) to be described in   Section 5.

  55 more annotations...

• 22 Jun 08
  

  Momo Moses

  LEEP12.1 ROL

• 23 May 08
  

  Kostas Maistrelis

  rdf xml w3c semanticweb

• 14 May 08
  

  ricardo power
• 27 Apr 08
  

  Edison Morais

  Documentação oficial da W3C sobre RDF

  semantic web RDF XML W3C documentation

• 22 Apr 08
  

  kundeng06

  Links Study current

• 18 Apr 08
  

  Pere Cortada

  rdf semanticweb w3c xml web reference tutorial

• 12 Apr 08
  

  DJHell .

  RDF semantisches Web W3C development

• 27 Mar 08
  

  scmoral

  The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF.

  rdf semanticweb Semantic tutorial taxonomy tagging web2.0 w3c

• 28 Feb 08
  

  Andy Jackson

  rdf planets

• 27 Feb 08
  

  Luis Martinez-Uribe

  interoperability standards

• 24 Feb 08
  

  Dan Unknow

  rdf

• 11 Feb 08
  

  rgarwood

  rdf reference tutorial

• 29 Jan 08
  

  jozilla

  del.icio.us imported rdf tutorial

• 14 Dec 07
  

  rob_cornelius

  rdf

• 04 Dec 07
  

  hamming229
  • RDF refers to a set of URIrefs (particularly a set intended for a specific purpose) as a vocabulary. Often, the URIrefs in such vocabularies are organized so that they can be represented as a set of QNames using a common prefix
  • The URIrefs in this RDF vocabulary all begin with http://www.w3.org/1999/02/22-rdf-syntax-ns#, conventionally associated with the QName prefix rdf:
• 30 Oct 07
  

  Brian Kelly

  minerva-2008

• 11 Sep 07
  

  Marcel Otto

  rdf to_read

• 16 Aug 07
  

  Adelbert G

  - already read to section 2.3

  RDF primer semanticWeb xml delicious original

• 14 Aug 07
  

  Thomas F.

  semanticweb cs reference manual tutorial rdf xml

• 03 Jun 07
  

  Lee Dryburgh

  rdf tutorial primer

• 31 May 07
  

  rahulg
  • by generalizing the concept of a "Web resource", RDF can  also be used to represent information about things that can be  identified on the Web, even when they cannot be directly  retrieved on the Web.
  • RDF is intended for situations in which this information   needs to be processed by applications, rather than being   only displayed to people.
  • The ability to exchange information between  different applications means that the information may be made  available to applications other than those for which it was  originally created.
  • To make this discussion somewhat more concrete as soon as  possible, the group of statements "there is   a Person   identified by http://www.w3.org/People/EM/contact#me, whose name is  Eric Miller, whose email address is em@w3.org, and whose title is  Dr." could be represented as the RDF graph in
  • RDF also provides an XML-based syntax (called RDF/XML) for  recording and exchanging these graphs
  • while English is good for communicating between  (English-speaking) humans, RDF is about making  machine-processable statements.
  • the idea of using  URI references to identify the things referred to  in RDF statements
  • RDF's basic statement concepts
  • RDF/XML as a machine-processable way to  represent RDF statements

  7 more annotations...

• 06 May 07
  

  Matthias Käppler

  rdf semweb

• 25 Apr 07
  

  Mark Dunn

  RDF

• 13 Apr 07
  

  Sean Carmody

  imported Computing Languages xml markup rdf

• 06 Apr 07
  

  Tobias Lee

  "The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF."

  metadata reference taxonomy web {project} W3C developer

• 25 Feb 07
  

  Tari Nz

  RDF semanticweb SKOS_semanticweb

• 24 Jan 07
  

  Konrad .

  documentation semantic_web web xml

• 19 Jan 07
  

  avivajazz jazzaviva

  This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic concepts of RDF and describes its XML syntax. It describes how to define RDF vocabularies using the RDF Vocabulary Description

• 09 Jan 07
  

  B P

  RDF documentation XML

• 06 Jan 07
  

  ramraj edagutti

  From Internet Explorer F Forums R RFC X XML Imported Bookmarks

• 03 Dec 06
  

  Shannon Holman

  rdf semanticweb xml w3c

• 19 Nov 06
  

  Alan Dean

  This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF.

  w3c Recommendation RDF

• 14 Nov 06
  

  Brian Kenyon

  w3c tutorial xml rdf @Read

• 13 Nov 06
  

  jeanjordaan

  This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic concepts of RDF and describes its XML syntax. It describes how to define RDF vocabularies using the RDF Vocabulary Description

  rdf xml semanticweb w3c reference web semantic

• 10 Oct 06
  

  Guillaume Hatt

  rdf delicious

• 21 Sep 06
  

  Nishith Prabhakar

  imported:del.icio.us knuggets semanticweb system:imported

• 08 Sep 06
  

  Luciano Seta

  rdf

• 28 Aug 06
  

  Kyle Fenton

  rdf xml metadata

• 24 Aug 06
  

  Fabien Gandon

  The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web. This Primer is designed to provide the reader with the basic knowledge required to effectively use RDF. It introduces the basic conc

  recommendation W3C semweb semanticweb semantic semantic_web rdf web KnowledgeRepresentation metadata

• 

  toxi

  datastructures webdev xml

• 10 Aug 06
  

  Gautham

  rdf primer delicious-import

• 02 Aug 06
  

  Sean O'Steen

  howto programming RDF W3C web2.0

• 21 Jul 06
  

  Rüdiger Schütz

  semantic_web article knowledge local metadata ontologies programming rdf reference research RSS semantic semanticweb semweb tagging taxonomy topicmap web webdesign webdev xml w3c

• 23 Jun 06
  

  Idel Lopez

  rdf xml semanticweb W3C web semantic reference XUL webdev

• 01 Jun 06
  

  lgsiigo

  RDF Primer

  RDF semanticweb semantic tutorial reference metadata

• 11 May 06
  

  Francisca Munoz

  rdf w3c

  • "there is   a Person   identified by http://www.w3.org/People/EM/contact#me, whose name is  Eric Miller, whose email address is em@w3.org, and whose title is  Dr."
  • However,  unlike conventional hypertext, RDF URIs can refer to any  identifiable thing, including things that may not be directly  retrievable on the Web (such as the person Eric Miller).
  • RDF is intended to provide a simple way to make statements  about Web resources,
  • RDF is based on the idea that the things being described  have properties  which have values
  • Specifically,  the part that identifies the thing the statement is about (the  Web page in this example) is called the subject.  The part that identifies the property or characteristic of the  subject that the statement specifies (creator, creation-date,  or language in these examples) is called the predicate,  and the part that identifies the value of that property is  called the object.
  • RDF is intended for situations in which this information   needs to be processed by applications, rather than being   only displayed to people.

  4 more annotations...

• 25 Apr 06
  

  Eric Harris-Braun

  RDF XML meaning URI

• 21 Apr 06
  

  mccraig mccraig

  rdf primer

• 20 Apr 06
  

  Carlos Hills

  Standards

• 27 Jan 06
  

  alimanfoo

• 14 Jan 06
  

  stracciatella

  rdf w3c-spec

• 12 Jan 06
  

  readmore

  best general explanation of RDF

  rdf semanticweb w3c xml web reference semantic

• 21 Nov 05
  

  Sam

  research information organization metadata xml RDF

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.