tmdinosaurcenter
/
dwc
mirror of https://github.com/tdwg/dwc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

First pass at cleanup on RDF guide and headers of other docs

This commit is contained in:
Steve Baskauf 2018-09-23 21:14:29 -05:00
parent 6dc010a573
commit a9a54d929b
5 changed files with 190 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
docs/namespace/index.md
View File

@ -10,16 +10,16 @@ Date created
: 2009-02-12
Part of TDWG Standard
: [http://www.tdwg.org/standards/450/](http://www.tdwg.org/standards/450/)
: <http://www.tdwg.org/standards/450/>
This version
: [http://rs.tdwg.org/dwc/terms/namespace/2018-08-26](http://rs.tdwg.org/dwc/terms/namespace/2018-08-26)
: <http://rs.tdwg.org/dwc/terms/namespace/2018-08-26>
Latest version
: [http://rs.tdwg.org/dwc/terms/namespace/](http://rs.tdwg.org/dwc/terms/namespace/)
: >http://rs.tdwg.org/dwc/terms/namespace/>
Previous version
: [http://rs.tdwg.org/dwc/terms/namespace/2013-09-23](http://rs.tdwg.org/dwc/terms/namespace/2013-09-23)
: <http://rs.tdwg.org/dwc/terms/namespace/2013-09-23>
Abstract
: All terms in the Darwin Core must be assigned a unique Uniform Resource Identifier (URI). For convenience, the term URIs that are assigned and managed by the Darwin Core Task Group are grouped into collections known as Darwin Core namespaces. This document describes how term URIs are allocated by the Darwin Core Maintenance Group and the policies associated with Darwin Core namespaces.

208
docs/rdf/index.md
View File

@ -1,58 +1,56 @@
# Darwin Core RDF Guide
# Darwin Core RDF guide
Title
: Darwin Core RDF Guide
: Darwin Core RDF guide
Date Issued
: 2015-03-27
Date Modified
Date version issued
: 2016-04-25
Date created
: 2015-03-27
Part of TDWG Standard
: <http://www.tdwg.org/standards/450/>
This version
: <http://rs.tdwg.org/dwc/terms/guides/rdf/2015-06-02>
Latest version
: <http://rs.tdwg.org/dwc/terms/guides/rdf/>
Previous version
: http://rs.tdwg.org/dwc/terms/guides/rdf/2015-03-27
Abstract
: This guide is intended to facilitate the use of Darwin Core terms in the Resource Description Framework (RDF). It explains basic features of RDF and provides details of how to expose data in the form of RDF using Darwin Core terms and terms from other key vocabularies. It defines terms in the namespace http://rs.tdwg.org/dwc/iri/ which are intended for use excusively with non-literal objects.
: This guide is intended to facilitate the use of Darwin Core terms in the Resource Description Framework (RDF). It explains basic features of RDF and provides details of how to expose data in the form of RDF using Darwin Core terms and terms from other key vocabularies. It defines terms in the namespace ```http://rs.tdwg.org/dwc/iri/``` which are intended for use excusively with non-literal objects.
Contributors
: Steve Baskauf (TDWG RDF/OWL Task Group), John Wieczorek (TDWG Darwin Core Task Group), John Deck (Genomic Biodiversity Working Group), Campbell Webb (TDWG RDF/OWL Task Group), Paul J. Morris (Harvard University Herbaria/Museum of Comparative Zoölogy), Mark Schildhauer (National Center for Ecological Analysis and Synthesis) (KUNHM)
Legal
: This document is governed by the standard legal, copyright, licensing provisions and disclaimers issued by the Taxonomic Databases Working Group.
Part of TDWG Standard
: [http://www.tdwg.org/standards/450/](http://www.tdwg.org/standards/450/)
Creator
: Darwin Core and RDF/OWL Task Groups
Identifier
: http://rs.tdwg.org/dwc/2015-06-02/terms/guides/rdf/
Bibliographic citation
: Darwin Core and RDF/OWL Task Groups. 2015. Darwin Core RDF guide. Biodiversity Information Standards (TDWG). http://rs.tdwg.org/dwc/terms/guides/rdf/
Latest Version
: [http://rs.tdwg.org/dwc/terms/guides/rdf/](http://rs.tdwg.org/dwc/terms/guides/rdf/index.htm)
Replaces
: http://rs.tdwg.org/dwc/2015-03-27/terms/guides/rdf/
Document Status
: Current Standard
## 1 Introduction
## 1 Introduction (non-normative)
Each method of encoding information using Darwin Core [[DWC](http://rs.tdwg.org/dwc/index.htm)] has a guide explaining how to use the Darwin Core terms in that situation. This is the guide for encoding biodiversity data using the Resource Description Framework [[RDF](http://www.w3.org/TR/rdf11-concepts/)].
### 1.1 Audience
The Darwin Core RDF Guide is targeted toward those who wish to share biodiversity data described by Darwin Core (DwC) properties using RDF. It describes how community best practices for expressing fundamental information about resources using RDF relate to Darwin Core terms, and clarifies how Darwin Core terms should be used in RDF with literal (string) and non-literal (IRI reference) objects. It is not intended to explain the model and syntax of RDF. For a general introduction to RDF in a biodiversity context, see the [[RDF-BEGINNERS-GUIDE](https://github.com/tdwg/rdf/blob/master/Beginners.md)]. For a more detailed introduction to RDF, see the [[RDF-PRIMER](http://www.w3.org/TR/rdf11-primer/)].
The Darwin Core RDF Guide is targeted toward those who wish to share biodiversity data described by Darwin Core (DwC) properties using RDF. It describes how community best practices for expressing fundamental information about resources using RDF relate to Darwin Core terms, and clarifies how Darwin Core terms should be used in RDF with literal (string) and non-literal (IRI reference) objects. It is not intended to explain the model and syntax of RDF. For a general introduction to RDF in a biodiversity context, see the [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners)]. For a more detailed introduction to RDF, see the [[RDF-PRIMER](http://www.w3.org/TR/rdf11-primer/)].
### 1.1 Status of the content of this document
Sections of this document are explicitly identified as either normative or non-normative. All numbered examples are non-normative, even if they fall within sections designated as normative. Tables may be designated as non-normative, even if they fall within sections designated as normative.
### 1.2 Rationale
### 1.2 Rationale (non-normative)
Darwin Core is a vocabulary which provides terms that can be used to describe the properties and types of entities (known in RDF as "resources") in the biodiversity realm. Darwin Core is a general purpose vocabulary because its terms can be used as part of a number of data transfer systems. RDF differs in several important ways from other data transfer systems for which DwC usage guides exist ([[TEXTGUIDE](http://rs.tdwg.org/dwc/terms/guides/text/)] and [[XMLGUIDE](http://rs.tdwg.org/dwc/terms/guides/xml/)]). By its nature, RDF is a distributed system. It is assumed that data from one provider will be linked to data from other providers. This also implies that it is always possible to discover new data properties about a particular resource and that those properties may be described using unfamiliar terms. This differs significantly from other data transfer systems where there must be a pre-existing agreement (in the form of a federation schema or human-understandable document) between the sender and receiver about the format of the data and the organization and interpretation of the terms within records. Because RDF is intended to facilitate data and metadata discovery by machines (actually computer programs known as semantic clients or just "clients"), the meaning and use of terms must be well-defined and discoverable by clients without human intervention. To facilitate cross-referencing of resources among different data providers, resources must be identified using standardized, machine-understandable, and globally unique identifiers known as internationalized resource identifiers (IRIs). Finally, because anyone can make statements about a resource without agreeing to a pre-determined schema, RDF by its nature is a highly normalized network of relationships, in contrast to typical database tables which are by their nature "flat". Because of these differences, effective use of RDF requires that its users adhere to what are essentially evolving social conventions about identifiers, data transfer protocols, and application of vocabularies. Some of these conventions will be described in the following sections.
### 1.3 Features of RDF
### 1.3 Features of RDF (non-normative)
This section describes some of the basic features of RDF. It is not intended as a tutorial on RDF, but rather to provide enough information about the features of RDF to explain why specific guidelines for the use Darwin Core in RDF are necessary and why an additional Darwin Core namespace has been created.
#### 1.3.1 Serialization and syntax
#### 1.3.1 Serialization and syntax (non-normative)
The RDF model itself is independent of any specific serialization syntax. The following diagram represents a set of facts about an image in a graphical form easily understood by humans.
@ -96,13 +94,13 @@ Abbreviated UIRIs will be shown in _italics_ in the form _namespace:localName_,
XML is a widely understood form of RDF serialization. Therefore, all examples given here will be shown as RDF/XML. In most cases, they will also be shown in Turtle. For more detailed information about RDF serialization, see part 3 of the Beginner's Guide to RDF [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners)] and the references cited there.
#### 1.3.2 Internationalized Resource Identifier (IRI)
#### 1.3.2 Internationalized Resource Identifier (IRI) (non-normative)
Data providers make use of a variety of identifiers to refer to resources they wish to provide. These identifiers may be locally unique within the provider's database, or they may be globally unique. Providers have sought to make their identifiers globally unique through such means as "Darwin Core Triplets" (institutionCode:collectionCode:catalogNumber) and creation of UUIDs [[UUID](http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ics.htm?csnumber=62795)]. However, only identifiers in the form of IRIs [[IRI](http://tools.ietf.org/html/rfc3987)] can be valid subjects of statements (known as RDF triples) in RDF, so neither “Darwin Core Triples” nor UUIDs can be used in unmodified form for that purpose. IRIs are a superset of a narrower form of identifiers known as Uniform Resource Identifiers (URIs) that can be used in place of IRIs [[URI](http://tools.ietf.org/html/rfc3986)]. This document will refer exclusively to IRIs with the understanding that URIs may be used in place of IRIs.
The most familiar form of IRI is a Uniform Resource Locator (URL) which not only identifies a resource, but provides information about retrieving an information resource (i.e., a resource that can be transmitted in electronic form) such as text in the form of an HTML web page. However, in general IRIs may identify non-information resources (physical or conceptual entities) that are not transmittable electronically, e.g., <http://bioimages.vanderbilt.edu/contact/kirchoff#coblea>, a person. If a client attempts to retrieve a non-information resource by dereferencing its HTTP IRI, a process called content negotiation [[HTTP-CONTENT-NEGOTIATION](http://tools.ietf.org/html/rfc2616#section-12)] is used to refer the client to the IRI of an information resource representation of the non-information resource. For humans, this is usually a web page, while for semantic clients (machines) the representation is a document in the form of RDF/XML. For more detailed information about IRIs see part 1 of the Beginner's Guide to RDF [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners)] and the references cited there.
##### 1.3.2.1 Persistent Identifiers
##### 1.3.2.1 Persistent Identifiers (normative)
Best practices dictate that identifiers (known as persistent identifiers or globally unique identifiers: GUIDs) which are used to identify resources of permanent interest be globally unique, referentially consistent, and persistent [[GUID-STANDARD](http://www.tdwg.org/standards/150/)]. If those identifiers are to be used to identify subject resources in RDF, they must also be in the form of an IRI. This has two implications for data providers.
@ -130,17 +128,17 @@ For a more detailed introduction to persistent identifiers, see the GBIF Beginne
Based on the precedent set by the TDWG LSID Applicability Statement standard [[GUID-STANDARD](http://www.tdwg.org/standards/150/)], it is recommended that URN-based IRIs be related to HTTP-proxied equivalents (if they exist) as described in [Section 2.2.3](./index.htm#2.2.3_Associating_a_URN_with_its_HTTP-proxied_equivalent).
##### 1.3.2.2 HTTP IRIs as self-resolving GUIDs
##### 1.3.2.2 HTTP IRIs as self-resolving GUIDs (normative)
Advocates of principles of Linked Data [[LINKED-DATA](http://linkeddata.org/)] prefer to use identifiers which follow the HTTP IRI scheme [[HTTP](http://tools.ietf.org/html/rfc2616)], known as "HTTP IRIs". In addition to being globally unique, such identifiers have the advantage of being dereferenceable using a widely implemented protocol . As such, it is possible to implement HTTP IRIs so that a human end user can obtain information about the resource using a conventional web browser. It is also possible to implement HTTP IRIs so that data (in the form of RDF) describing the resource can be discovered by a semantic client. In recognition of the advantages conferred by HTTP IRIs, the TDWG GUID Applicability Statement standard [[GUID-STANDARD](http://www.tdwg.org/standards/150/)] specifies in Recommendation 2 that "HTTP GET resolution must be provided for non-self-resolving GUIDs". For this reason, providers of biodiversity information who intend to make data available through RDF should plan to implement GUIDs that are persistent HTTP IRIs. This is not to the exclusion of other forms of non-self-resolving globally unique identifiers that can be associated with the HTTP IRI using the methods described in [Section 2](./index.htm#2_Implementation_Guide) of this guide.
### 1.4 Use of terms in RDF
#### 1.4.1 Well-known vocabularies
#### 1.4.1 Well-known vocabularies (non-normative)
Because RDF assumes no pre-existing agreement between data providers and consumers about the terms used as properties to describe resources, the likelihood that a consuming client will "understand" the meaning of an RDF triple will be increased if the provider uses terms from a well-known vocabulary. Some well-known general and biodiversity-related vocabularies are listed in the Introduction to the Beginner's Guide to RDF [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners#0.3.7._Biodiversity-related_and_General_vocabularies_and_ontolog)]. If no well-known term exists to represent a property needed to describe a resource, a data provider may "mint" its own term. In that case, the provider should assign the term an IRI, define the term in RDF, provide clear human-understandable documentation of how the term should be used, provide for dereferencing of the IRI, and commit to the long-term stability of the term IRI and definition.
#### 1.4.2 Appropriate use of terms
#### 1.4.2 Appropriate use of terms (normative)
Because of the machine-oriented nature of RDF, a provider must assume that a consuming client will not infer any meaning from a statement other than what is directly stated or what can be inferred logically from other statements made about the resources and terms involved in the statement. For example, a provider might use the name of a resource in a triple with the intention that the name represent the resource itself. However, if the term used as the predicate in the triple is designed to refer to resources themselves rather than names of resources, the client may fail to make the connection between the name and the resource itself. Depending on how the term is defined, the client may detect an inconsistency or draw unintended conclusions as described below. Inappropriate use of terms as RDF predicates can have unintended consequences because unlike text-based data transfer protocols, RDF is designed to allow clients to infer additional facts based on information contained in the definitions of the terms. For example, the definition of the term _foaf:depicts_ [[FOAF](http://xmlns.com/foaf/spec/)] contains a statement declaring its domain to be _foaf:Image_ . Thus a provider which describes a resource using a _foaf:depicts_ property is also implicitly (and perhaps unknowingly) declaring the resource to be an image. Terms which are defined using a form of RDF known as Web Ontology Language (OWL) [[OWL](http://www.w3.org/TR/owl2-overview/)] may have restrictions placed on their use. For example, declaring a term to be an _owl:ObjectProperty_ indicates that it is inconsistent for the value of that property to be a string literal (i.e., the value should be an IRI).
@ -148,7 +146,7 @@ For these reasons, terms should be used as predicates in RDF only after the data
For more detailed information about the implications of using terms that have range, domain, and subproperty declarations in RDF, see part 4 of the Beginner's Guide to RDF [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners)]. For more detailed information about how OWL is used to define complex properties of terms in RDF, see part 7 of the Beginner's Guide to RDF [[RDF-BEGINNERS-GUIDE](http://code.google.com/p/tdwg-rdf/wiki/Beginners)].
#### 1.4.3 Use of Darwin Core terms in RDF
#### 1.4.3 Use of Darwin Core terms in RDF (normative)
The general Darwin Core vocabulary, whose terms are in the _dwc:_ namespace (http://rs.tdwg.org/dwc/terms/), is designed primarily to facilitate the transfer of text-based records from relatively "flat" database tables. Because of this, the term recommendations associated with the general vocabulary suggest using text strings to refer to physical and conceptual entities, i.e., names to represent people, citations to represent articles, codes to represent institutions, etc. (The several kinds of roles intended for text strings are detailed in [Section 1.5](./index.htm#1.5_Roles_of_text_strings_as_values_of_properties_in_dwc:_namesp).) When a record has multiple values for a property, the general Darwin Core term definitions recommend that the multiple strings be concatenated and delineated in a single field to avoid forcing the creation of a more normalized data structure.
@ -158,11 +156,11 @@ In a perfect world, all data providers wishing to serve RDF would immediately re
This guide introduces the namespace **_dwciri:_** (http://rs.tdwg.org/dwc/iri/) whose terms are intended for use with non-literal objects. If a term in the _dwciri:_ namespace has an analogue in the _dwc:_ namespace having the same local name, the _dwciri:_ term will have the same meaning as its _dwc:_ counterpart. For example, _dwciri:recordedBy_ has the same meaning as _dwc:recordedBy_, but as an RDF predicate _dwciri:recordedBy_ is intended to be repeatable and have an IRI-reference object. Providers whose databases include the field _dwc:recordedBy_ with records containing concatenated lists of names can publish those values immediately as single RDF triples using _dwc:recordedBy_ as the predicate and containing one literal object which is the concatenated list string. In this manner, publication of data as RDF can begin immediately using the _dwc:_ terms without the requirement that every resource have an assigned IRI GUID. As the community develops mechanisms for discovering and reusing IRIs, data providers can make the shift to _dwciri:_ terms. As a part of their data updating and cleaning process providers or aggregators may eventually parse the strings, search a community IRI repository, and match strings with existing IRIs or create new ones if they do not already exist.
#### 1.4.4 Limitations of this guide
#### 1.4.4 Limitations of this guide (non-normative)
This guide provides general guidance about how Darwin Core property terms should be used as RDF predicates and specifies that Darwin Core class terms should be used in _rdf:type_ declarations ([Section 2.3.1.5](./index.htm#2.3.1.5_Classes_to_be_used_for_type_declarations_of_resources_de)). However, the Darwin Core standard does not specify precisely which resources should be included as instances of its classes nor does it declare domains for its property terms. Although the Darwin Core Quick Reference Guide [[DWC-GUIDE](http://rs.tdwg.org/dwc/terms/index.htm)] suggests which properties might be applied to instances of classes by organizing those property terms under class headings, Darwin Core leaves specific decisions about type declaration and property assignment to community consensus. Some examples which show varying approaches to assigning resources to Darwin Core classes and connecting them with object properties defined outside Darwin Core are provided in the Darwin Core informative ancillary web pages [[DWC-RDF-ANCILLARY](https://code.google.com/p/tdwg-rdf/wiki/DwCAncillary)].
### 1.5 Roles of text strings as values of properties in dwc: namespace
### 1.5 Roles of text strings as values of properties in dwc: namespace (non-normative)
When humans communicate in written language, they use strings of text characters to impart meaning. In some cases text strings may have a relatively unambiguous meaning. However, in many cases the exact meaning of a text string will depend on the context in which it is used. Take for example the text string “Germany”. That string may be intended to refer to a location bounded by some agreed-upon geographical borders. It may be intended to refer to a political entity, i.e., “the government of Germany”. It may be intended to refer to an entity that includes all of the inhabitants living with certain geographical borders. It may also be intended to be a name recorded in a certain language. Is “Germany” the same as “Deutschland”? Does “Germany” mean the same thing as the code “DE”? Is “Germany” the same as “Federal Republic of Germany”? The answers to all of these questions depends on what one means by “Germany”.
@ -170,25 +168,25 @@ In text-based data transfer systems, text strings are the predominant means by w
Because text-based systems depend on predetermined understandings about the meanings of data fields, users are not forced to consider carefully the role that the string values are intended to play. However, in RDF one cannot assume that a client will “know what I mean” when a string is provided. For that reason, it is worth examining the kinds of meanings that we intend when we provide string values for Darwin Core properties in the _dwc:_ namespace.
#### 1.5.1 Situations where a string is the standard means for encoding a resource
#### 1.5.1 Situations where a string is the standard means for encoding a resource (non-normative)
Numbers, dates, and titles are resources which are essentially conceptual, but whose meaning can be imparted rather completely and concisely by a string. This is particularly true if an datatype encoding scheme is specified for the string or if a language attribute is used to indicate the language of the title. In this situation, there is virtually no need to provide additional information about the resource other than the string itself. A literal object is sufficient in itself.
#### 1.5.2 Situations where a string value serves as a proxy for a non-information resource
#### 1.5.2 Situations where a string value serves as a proxy for a non-information resource (non-normative)
Humans commonly use name strings to represent resources that are physical or conceptual (i.e., non-information) resources. For example, the string “Vincent van Gogh” is used to represent the person whose name was Vincent van Gogh. If we made the statement “Starry Night” createdBy “Vincent van Gogh”, we do not mean that “Starry Night” was created by the name “Vincent van Gogh”, but rather that “Starry Night” was created by the person whose name was Vincent van Gogh. For that matter “Starry Night” is the name for a painting and we probably actually mean that the person Vincent van Gogh created the painting rather than the name of the painting (although he probably created both!). Unlike the first situation, such name strings themselves do not contain nearly all of the information that one might want to know about that non-information resource (e.g., date of creation, location at during a certain period of time, etc.) but they can serve as an identifier for the resource. In RDF, machine-processable IRIs are preferred over string names as identifiers for resources.
#### 1.5.3 Situations where a string value serves as a keyword to enable searching
#### 1.5.3 Situations where a string value serves as a keyword to enable searching (non-normative)
Imagine that a person identifies an oak tree as “Quercus alba”. The data associated with that identification may provide the property/value pair _dwc:scientificName_=”Quercus alba”. This implies that the person asserted that the tree was a representative of a taxon associated with the name _Quercus alba_. The data associated with the identification may also provide the property/value pair _dwc:order_=”Fagales”. One might think that this would imply that the person who asserted the identification also asserted that the tree was included in the order Fagales. However, it is likely that the person did not make such an assertion and in fact may have never even heard of the order Fagales. Rather, a database manager subscribing to a particular taxonomic hierarchy asserted that all identifications with a _dwc:scientificName_ value of “Quercus alba” should also have a property/value pair of dwc:order=”Fagales” in order to allow users of the database to search for identifications that were related because they shared the common value for that _dwc:order_ property.
The point is that in order to more accurately describe the real situation, there should be two separate sets of information: one which asserts that the person identified the tree as a representative of a taxon for which the scientific name “Quercus alba” is applied, and one which asserts the relationship between that taxa and higher taxa such as one to which the name “Fagales” is applied.
#### 1.5.4 Situations where a string value serves as an identifier
#### 1.5.4 Situations where a string value serves as an identifier (non-normative)
A number of Darwin Core properties specify that their values should be an identifier. There is significant ambiguity in the use of these properties because depending on the situation the value may be an identifier for the subject resource itself or it may be the identifier for a resource that is related in some way to the subject resource. In addition, Darwin Core sometimes recommends (but does not require) a GUID as a value, but does not require that the GUID be either an HTTP IRI nor an IRI in general.
#### 1.5.5 Implications for expressing Darwin Core string values as RDF
#### 1.5.5 Implications for expressing Darwin Core string values as RDF (non-normative)
To facilitate achieving the clarity that RDF makes possible, this guide provides different approaches for each of these four situations in which string values are provided. In the first three situations, the existing term from Darwin Core namespace _dwc:_ can be used with a literal value to expose the string value as it currently exists in a text-based database. This allows for the rapid deployment of RDF described in [Section 1.4.3](./index.htm#1.4.3_Use_of_Darwin_Core_terms_in_RDF) and is all that is required in the first situation ([Section 1.5.1](./index.htm#1.5.1_Situations_where_a_string_is_the_standard_means_for_encodi)). In the second situation ([Section 1.5.2](./index.htm#1.5.2_Situations_where_a_string_value_serves_as_a_proxy_for_a_no)), analogues of the existing _dwc:_ terms have been created in the _dwciri:_ namespace which are intended to be used with IRI-references rather than names. In the third situation ([Section 1.5.3](./index.htm#1.5.3_Situations_where_a_string_value_serves_as_a_keyword_to_ena)), new _dwciri:_ terms have been created to relate subject resources to IRI-identified object resources which form part of a hierarchy. If such a hierarchy already exists, the need is eliminated for separate terms (“convenience terms”) which relate the subject resource to all parts of the hierarchy, although those terms can still be used if they are convenient for facilitating string searches. The last situation ([Section 1.5.4](./index.htm#1.5.4_Situations_where_a_string_value_serves_as_an_identifier)) is more complex and a significant part of the implementation guide is devoted to the ways in which RDF should be structured to handle various kinds of identifiers.
@ -196,7 +194,7 @@ To facilitate achieving the clarity that RDF makes possible, this guide provides
### 2.1 Definitions
#### 2.1.1 Namespace abbreviations used in XML qualified names (QNames) in this document
#### 2.1.1 Namespace abbreviations used in XML qualified names (QNames) in this document (non-normative)
**Table 1**
@ -220,7 +218,7 @@ Extensible Metadata Platform Rights Management vocabulary | xmpRights: | http://
For brevity, the examples do not include namespace declarations, nor an _rdf:RDF_ container element. If a user wishes to test or validate an example, insert it into the container element defined in [Section 2.1.2](./index.htm#2.1.2_Generating_graphical_diagrams_and_triple_tables_for_the_ex).
#### 2.1.2 Generating graphical diagrams and triple tables for the examples
#### 2.1.2 Generating graphical diagrams and triple tables for the examples (non-normative)
The W3C RDF Validation Service [[W3C-RDF-VALIDATOR](http://www.w3.org/RDF/Validator/)] can be used to generate both a tabular listing and a graphical diagram of the triples that are included in the example XML serializations. Text from the examples can be placed inside the _rdf:RDF_ container element below, then pasted into the validator box to generate the desired output.
@ -245,7 +243,7 @@ xmlns:viaf="http://viaf.org/viaf/"
</rdf:RDF>
```
#### 2.1.3 Terminology
#### 2.1.3 Terminology (non-normative)
"Resource" is a general term for any kind of entity that can be described using RDF. Resources can be physical, conceptual, or digital entities. Statements about resources are made in RDF in the form of "triples" [[RDF-TRIPLES](http://www.w3.org/TR/2014/NOTE-rdf11-primer-20140624/#section-triple)]. A triple consists of a subject, a predicate, and an object:
@ -277,11 +275,11 @@ Turtle
The Dublin Core Metadata Initiative (DCMI) Abstract Model [[DCAM](http://dublincore.org/documents/abstract-model/)], which was designed to be compatible with RDF, describes subject resources using property-value pairs, which correspond to pairs of predicates and objects. When referring to Dublin Core terms (as well as Darwin Core, which is modeled on Dublin Core) "property" is used synonymously with "predicate" and "value" is used synonymously with "object". In Example 1, _foaf:maker_ is a property and _viaf:9854560_ is the value associated with that property. Predicates must be identified by IRIs. Objects of triples may be identified in three ways: 1) the object resource can be identified by an IRI reference, 2) the object can be identified by a non-IRI string, in which case it is called a literal, and 3) the object resource can also be left unidentified, in which case it is called a blank node or an anonymous node. Blank nodes are undesirable if it is important that other data providers be able to refer to the resource they represent. However, blank nodes may be preferable if external references to the resource are not relevant, or if the data provider is unable or unwilling to provide a stable IRI to identify the resource. IRI references and blank nodes can be the subjects of RDF triples, but literals cannot.
### 2.2 Subject resources
### 2.2 Subject resources (normative)
If the subject of an RDF triple is identified (i.e., not an anonymous node), it must be referenced by an IRI. This section describes how IRI identifiers are referenced in RDF and how non-IRI identifiers should be associated with the subject of the triple.
#### 2.2.1 Identifying subject resources using IRIs
#### 2.2.1 Identifying subject resources using IRIs (normative)
The _rdf:about_ attribute of the _rdf:Description_ element is used in RDF/XML to identify the subject of a triple:
@ -289,7 +287,7 @@ The _rdf:about_ attribute of the _rdf:Description_ element is used in RDF/XML to
<rdf:Description rdf:about="http://arctos.database.museum/guid/MVZ:Mamm:165861">
```
#### 2.2.2 Associating a string identifier with a subject resource
#### 2.2.2 Associating a string identifier with a subject resource (normative)
The Dublin Core term _dcterms:identifier_ should be used to associate a string literal identifier (e.g., UUID, "Darwin Core Triplet", or ARK) with an IRI-identified resource as shown here in RDF/XML:
@ -297,7 +295,7 @@ The Dublin Core term _dcterms:identifier_ should be used to associate a string l
<dcterms:identifier>58D31D52-713D-44B4-9FE9-CB2D9249C422</dcterms:identifier>
 
<dcterms:identifier>MVZ:Mamm:165861</dcterms:identifier>
<dcterms:identifier>ark:/12025/654xz321</dcterms:identifier>
```
@ -312,7 +310,7 @@ If an HTTP IRI is considered to be the identifier for a subject resource, it is
</rdf:Description>
```
#### 2.2.3 Associating a URN with its HTTP-proxied equivalent
#### 2.2.3 Associating a URN with its HTTP-proxied equivalent (normative)
The TDWG LSID Applicability Statement standard [[GUID-STANDARD](http://www.tdwg.org/standards/150/)] specifies in Recommendation 30 that "The description of all objects identified by an LSID **must** contain an _owl:sameAs_, _owl:equivalentProperty_ or _owl:equivalentClass_ statement expressing the equivalence between the object identifier in its standard form and its proxy version". This is illustrated by Example 3:
@ -337,15 +335,15 @@ Since LSIDs follow the URN IRI scheme, they can serve as the subject of any RDF
This practice can be extended to any URN. For example, _owl:sameAs_ can be used to relate the URN <urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6> to its HTTP-proxied equivalent <http://provider.org/f81d4fae-7dec-11d0-a765-00a0c91e6bf6> in a manner analogous to Example 3.
### 2.3 Predicates
### 2.3 Predicates (normative)
Most terms in the Darwin Core vocabulary can be used as predicates in triples to represent properties of subject resources. The full term IRI must be used, although with an appropriate namespace declaration, the namespace can be abbreviated ([Section 2.1.1](./index.htm#2.1.1_Namespace_abbreviations_used_in_XML_qualified_names_(QName)). RDF does not restrict the source of predicates, therefore Darwin Core terms can be mixed with terms from other vocabularies. This includes the important predicate _rdf:type_ which is used to indicate the class of which the subject resource is an instance. There is no prohibition in RDF against repeating properties.
#### 2.3.1 Declaring the type of the resource
#### 2.3.1 Declaring the type of the resource (non-normative)
In RDF, a resource may be characterized by declaring that it is an instance of a class. Indicating that a resource is an instance of a class provides several benefits. It allows a consumer to narrow the results of a search by limiting the search to certain types of resources. It suggests to data providers what sorts of properties should be used to describe a resource. It allows consumers to anticipate what sorts of properties they might expect to be provided for that resource and allows developers to build applications that exploit those expectations. Because of these benefits, RDF provides several built-in mechanisms for asserting class membership, most notably the _rdf:type_ property [[RDF-TYPE](http://www.w3.org/TR/rdf-schema/#ch_type)] which is used to state that a resource is an instance of a class. There is nothing that prohibits assigning more than one _rdf:type_ property to a resource. In fact, there may be a benefit in describing a resource as a member of both a class which has specific meaning within a narrow community and a more well-known class which has a broader meaning and is therefore more likely to be understood by generic clients. For instance, a resource may be typed as both a _dwc:PreservedSpecimen_ and a _dcmitype:PhysicalObject_.
##### 2.3.1.1 rdf:type statement
##### 2.3.1.1 rdf:type statement (normative)
The predicate _rdf:type_ is defined to have an object that is a class. The class should be identified by an IRI reference (not by a literal) as in Example 4:
@ -379,7 +377,7 @@ In Turtle serialization, _rdf:type_ can be abbreviated as "_a_" (Example 4). In
This example serializes the exact same two triples as Example 4. The _rdf:type_ triple is implied by the container element name.
##### 2.3.1.2 rdf:type assertion through domain and range declarations
##### 2.3.1.2 rdf:type assertion through domain and range declarations (normative)
The RDF Schema (RDFS) specification [[RDFS](http://www.w3.org/TR/rdf-schema/)] defines two terms that assert _rdf:type_ implicitly when certain predicates are used. When a predicate _P_ having the property
@ -445,7 +443,7 @@ Turtle
No terms defined within the Darwin Core namespace have range or domain declarations. However, some terms imported into Darwin Core from Dublin Core do have domain or range declarations. [Sections 3.2](./index.htm#3.2_Imported_Dublin_Core_terms_for_which_only_literal_objects_ar) and [3.3](./index.htm#3.3_Imported_Dublin_Core_terms_that_have_non-literal_objects_and) of this guide gives the declared ranges and domains when they are asserted for such terms.
##### 2.3.1.3 Explicit vs. inferred type declarations
##### 2.3.1.3 Explicit vs. inferred type declarations (normative)
Because the use of a predicate having a range or domain declaration implies the _rdf:type_ of a resource, data providers should exercise caution in using any such term in a non-standard way. For example, if the property _foaf:familyName_ were used with a specimen (e.g., to indicate the taxonomic family), that use would imply that the specimen was a _foaf:Person_ . However, it cannot be assumed that all clients will perform the reasoning necessary to infer the _rdf:type_ declarations implied by range and domain declarations. Therefore, if a data provider feels that it is important for a consumer to know that a resource is an instance of a particular class, the provider should type the resource using an explicit _rdf:type_ triple even if that asserts the same information that could be inferred from a domain or range declaration. For example, if providers of images want to assure that an image will be found in a query for resources having _rdf:type_ _foaf:Image_, they should not assume that describing the image using the property _foaf:depicts_ will accomplish that because of the range declaration of _foaf:depicts_. It would be safer to include
@ -461,7 +459,7 @@ in the description of the image. In fact, the provider would probably also want
in the description so that clients searching for instances of either _foaf:Image_ or _dcmitype:StillImage_ class resources would find the image.
##### 2.3.1.4 Other predicates used to indicate type
##### 2.3.1.4 Other predicates used to indicate type (normative)
Both the Dublin Core and Darwin Core define terms that can be used to describe the nature of a resource: _dcterms:type_ and _dwc:basisOfRecord_ respectively. However, using these terms to describe the nature of the subject resource is not a substitute for use of _rdf:type_. The DCMI notes on RDF semantics [[DC-RDF-SEMANTICS](http://dublincore.org/documents/dc-rdf/#sect-5)] recommend that "applications implementing this specification primarily use and understand _rdf:type_ in place of _dcterms:type_ when expressing Dublin Core metadata in RDF, as most RDF processors come with built-in knowledge of _rdf:type_." A similar argument could be made for the use of _rdf:type_ over _dwc:basisOfRecord_. Including _dc:type_, _dcterms:type_, and _dwc:basisOfRecord_ in an RDF description should be considered optional, while including _rdf:type_ should be considered highly recommended. A _dwciri:_ analogue ([Section 2.5](./index.htm#2.5_Terms_in_the_dwciri:_namespace)) of _dwc:basisOfRecord_ should not be used. Use _rdf:type_ instead when the object is an IRI reference. Here is an example that describes a specimen using several of the terms that define the nature of a resource explicitly, including multiple _rdf:type_ declarations:
@ -492,7 +490,7 @@ Turtle
Refer to [Sections 2.4.3](./index.htm#2.4.3_Object_resources_that_have_been_previously_represented_by) and [2.5](./index.htm#2.5_Terms_in_the_dwciri:_namespace) for an explanation of the distinction between terms in the _dc:_, _dcterms:_, _dwc:_, and _dwciri:_ namespaces.
##### 2.3.1.5 Classes to be used for type declarations of resources described using Darwin Core
##### 2.3.1.5 Classes to be used for type declarations of resources described using Darwin Core (normative)
The TDWG GUID Applicability Statement standard [[GUID-STANDARD](http://www.tdwg.org/standards/150/)] specifies that an object in the biodiversity domain that is identified by a GUID should be typed using a well-known vocabulary. With this recommendation in mind, it should be considered a best practice to provide information about the type (i.e., class membership) of any resource that is assigned a persistent identifier in the form of an IRI. Since Darwin Core is a well-known vocabulary and a ratified TDWG standard, its classes should be used for typing in preference to classes in parts of the TDWG ontology which are not ratified standards and are effectively deprecated. The human-readable definitions of the Darwin core classes provide guidance for deciding the types to assign to resources, although community consensus may be necessary to classify some of the more complex kinds of resources. ([Section 1.4.4](./index.htm#1.4.4_Limitations_of_this_guide))
@ -506,11 +504,11 @@ _dcmitype:Sound_
_dcmitype:PhysicalObject_
### 2.4 Object resources
### 2.4 Object resources (non-normative)
[Section 1.3.1](./index.htm#1.3.1_Serialization_and_syntax) of the Introduction to this guide shows how the object of an RDF triple can be a expressed as either a string literal or an IRI reference. It is also possible to have non-literal objects that are not identified by an IRI. These are known as blank or anonymous nodes. This section describes how to express objects in each of these three forms. [Section 1.4.3](./index.htm#1.4.3_Use_of_Darwin_Core_terms_in_RDF) and [Section 1.5](./index.htm#1.5_Roles_of_text_strings_as_values_of_properties_in_dwc:_namesp) of the Introduction explains the issues involved in exposing data for which values as string literals (e.g., names, citations, and codes) are used as proxies for non-literal resources. This section also discusses strategies for expressing such data as RDF.
#### 2.4.1 Literal object resources
#### 2.4.1 Literal object resources (normative)
Some resources such as titles, dates, and numbers can be intrinsically expressed as strings. In cases where it is appropriate for the object of a triple to be a string, in RDF/XML the string is placed in a container element whose qualified name is the property:
@ -518,7 +516,7 @@ Some resources such as titles, dates, and numbers can be intrinsically expressed
<dwc:catalogNumber>s1987-00397</dwc:catalogNumber>
```
##### 2.4.1.1 Typed literals
##### 2.4.1.1 Typed literals (normative)
Because literals cannot be the subjects of RDF triples, it is not possible to describe the properties of literals extensively in RDF. However, specifying a datatype IRI for a literal provides a mechanism that allows an client to interpret the nature of the resource that the string denotes. [[RDF-DATATYPE-SEMANTICS](http://www.w3.org/TR/rdf11-mt/#literals-and-datatypes)] [[RDF-DATATYPE-SYNTAX](http://www.w3.org/TR/rdf-syntax-grammar/#section-Syntax-datatyped-literals)]
@ -572,11 +570,11 @@ In the RDF 1.1 specification, datatype D-entailment is a direct extension to bas
[Section 3.4](./index.htm#3.4_Terms_defined_by_Darwin_Core_that_are_expected_to_be_used_on) indicates which Darwin Core terms would be appropriately used with values having datatype or language attributes.
##### 2.4.1.2 Terms intended for use with literal objects
##### 2.4.1.2 Terms intended for use with literal objects (normative)
The definitions of some terms make it clear that they should be used with literal objects. Darwin Core specifically "imports" several Dublin Core terms [[DC-TERMS](http://dublincore.org/documents/DC-TERMS/)] into its vocabulary for use in describing biodiversity data. In some cases, terms in the _dcterms:_ namespace have range declarations of _rdfs:Literal_ and are therefore understood to be intended for use with literal objects (strings). In some vocabularies, certain terms are required to have literal objects because in their definitions they are declared to be _owl:Datatype_ properties. In the case of Darwin Core terms in the _dwc:_ (http://rs.tdwg.org/dwc/terms/) namespace, the normative term definitions in RDF do not include any declarations that indicate whether the terms should be used with literal or IRI reference objects. (Exceptions to this are the various date-related terms, which inherit the range _rdfs:Literal_ because they are _rdfs:subPropertyOf_ _dcterms:date_.) However, because the _dwc:_ terms were originally designed to accommodate text and XML data transfer, their definitions generally specify how term values should be expressed as string literals. This guide establishes the convention that terms in the _dwc:_ namespace should be restricted to use with literal objects so that their use in RDF will be consistent with their definitions. As discussed in [Section 1.4.3](./index.htm#1.4.3_Use_of_Darwin_Core_terms_in_RDF) and [Section 2.5](./index.htm#2.5_Terms_in_the_dwciri:_namespace), this guide introduces a separate namespace http://rs.tdwg.org/dwc/iri/ (abbreviated as _dwciri:_) for additional Darwin Core terms which are intended to have objects that are IRI references.
#### 2.4.2 Non-literal object resources
#### 2.4.2 Non-literal object resources (normative)
Resources that are physical or conceptual often cannot be intrinsically represented as string literals and if identified, they are referenced in RDF by IRIs. Digital resources (e.g., images, web pages, etc.) could be represented as literals (the encoded content of the resource), but because many characters would be required to do that, they are usually referenced as independent entities through IRIs. In RDF/XML an IRI reference to a non-literal object can be made using the attribute _rdf:resource_ in an empty XML element:
@ -607,7 +605,7 @@ If the non-literal object is not identified by an IRI (i.e., it is a blank node)
<dcterms:rightsHolder>
```
##### 2.4.2.1 When should non-literal object resources be described within the same document?
##### 2.4.2.1 When should non-literal object resources be described within the same document? (non-normative)
There are positive and negative aspects to describing a resource within the same document that references it. If the IRI is not dereferenceable, either because the IRI is not a type that can be dereferenced by HTTP (e.g., a URN) or because the issuer of the IRI is temporarily or permanently failing to respond to HTTP calls, then providing minimal information about the resource in the referencing document may be beneficial. For example, if a property referred to a printed book which had an ISBN but no HTTP IRI, as in:
@ -665,11 +663,11 @@ Turtle
the rights holder object IRI is managed by an institution other than the image owner. That institution might update the data associated with the IRI at any time. So it would probably be best to simply let consumers retrieve data about the rights holder through dereferencing the IRI.
###### 2.4.2.1.1 Objects identified by LSIDs
###### 2.4.2.1.1 Objects identified by LSIDs (normative)
In the previous example, the HTTP IRI used as the object of the _dcterms:rightsHolder_ property was an HTTP-proxied form of an LSID. Because an LSID is a URN and therefore a type of IRI, the RDF specification does not prohibit the use of an LSID as an IRI referenced object. However, the TDWG LSID Applicability Guide standard dictates that LSIDs must not be used as the object of RDF triples (Recommendation 31 of [[GUID-STANDARD](http://www.tdwg.org/standards/150/)]) because a client would not necessarily be able to dereference the LSID to discover additional information about the object resource. The HTTP-proxied version of the LSID should be used instead (see [Section 2.2.3](./index.htm#2.2.3_Associating_a_URN_with_its_HTTP-proxied_equivalent)). See the Darwin Core informative ancillary web pages [[DWC-RDF-ANCILLARY](https://code.google.com/p/tdwg-rdf/wiki/DwCAncillary)] for more information about using LSIDs in RDF.
##### 2.4.2.2 Objects which are blank (anonymous) nodes
##### 2.4.2.2 Objects which are blank (anonymous) nodes (non-normative)
Under most circumstances, it is desirable to refer to a non-literal object resource by an IRI because omitting an IRI reference makes it impossible to associate an external reference with the object resource. In the following example:
@ -700,7 +698,7 @@ Turtle
the described subject resource refers to an object resource that is not identified with an IRI, that is, an object resource represented by a blank node. From the properties of the unidentified resource we know that the object resource is a _foaf:Document_ from 2003 entitled "Collection notes" and created by Joe Curator. By using a blank node to represent the resource, the properties of that resource can be described and collectively associated with the _dcterms:references_ property without requiring the data provider to mint an IRI for that resource. The data provider may feel that there is no need for another provider to refer to that resource, or the provider may be unwilling or unable to maintain a separate identifier for the resource. For example, in Example 12, the data provider may not have had access to an IRI identifier for the Trustees of the University of Lavonia and might not be interested in taking on the job of assigning one. At some future point, the provider could replace the blank node with an IRI reference if an IRI for the Trustees of the University of Lavonia were discovered.
#### 2.4.3 Object resources that have been previously represented by literals but which are actually non-literal resources
#### 2.4.3 Object resources that have been previously represented by literals but which are actually non-literal resources (non-normative)
In databases the names of entities have frequently been used to represent the entities themselves. For example, the name of a person is often used as a proxy for the person, or an abbreviation for a language has been used to represent the language itself. Prior to the creation of the DCMI Abstract Model, many data which were described using terms in the legacy Dublin Core namespace _dc:_ (http://purl.org/dc/elements/1.1/) followed the historical practice of using the name of an entity to represent a non-literal entity. Extending this practice to RDF would result in representations such as this:
@ -723,7 +721,7 @@ Turtle
However, over time, the community of RDF users has come to consider it a best practice to distinguish between a string (such as a name) and the thing that the string represents [[USING-DC-CREATOR](http://wiki.foaf-project.org/w/UsingDublinCoreCreator)]. To make the distinction between strings and the resources they represent, there has been an effort to clarify whether particular terms should be used with literal objects, or with IRI reference objects.
##### 2.4.3.1 Literal values for non-literal resources in Dublin Core
##### 2.4.3.1 Literal values for non-literal resources in Dublin Core (normative)
The introduction of the DCMI Abstract Model (DCAM) and subsequent guidelines for the use of Dublin Core terms in RDF [[DC-RDF](http://dublincore.org/documents/dc-rdf/#sect-4)] were intended to clarify the use of Dublin Core terms with literal and non-literal objects [[DC-RDF-NOTES](http://dublincore.org/documents/2008/01/14/dc-rdf-notes/#sect-3)]. In particular, ranges were declared for terms in the _dcterms:_ namespace (http://purl.org/dc/terms/) with the intention of clarifying whether each term was intended for use with a literal or a non-literal value. For example, _dcterms:bibliographicCitation_ has the range _rdfs:Literal_, while _dcterms:creator_ has range _dcterms:Agent_. Because the term _dcterms:creator_ has a non-literal range, it should be used with an object that is an IRI reference as illustrated in the following example:
@ -745,7 +743,7 @@ Turtle
The Dublin Core RDF guidelines [[DC-RDF](http://dublincore.org/documents/dc-rdf/#sect-4)] provided a mechanism using the term _rdf:value_ to permit legacy string literal data to be associated with Dublin Core terms in the _dcterms:_ namespace that were not intended for use with literal objects. Using this mechanism, a non-literal resource could be represented by a blank node having an _rdf:value_ property whose value was the legacy string literal. This value is known as a “value string”. However, the mechanism which involves using _rdf:value_ as a predicate has not been widely implemented. At the time when the _dcterms:_ terms were defined, terms in the _dc:_ namespace were left without range declarations. Thus it has been considered acceptable to use the _dc:_ namespace terms with legacy string literals (i.e., value strings) as shown in Example 15 [[DC-LINKED-DATA](http://wiki.dublincore.org/index.php/User_Guide/Publishing_Metadata#Legacy_namespace)]. Many providers of non-RDF data may have used literal values for terms in the _dcterms:_ namespace that have non-literal ranges. Note that all terms in the _dcterms:_ namespace that have corresponding terms in the _dc:_ namespace (i.e., terms with identical local names sensu [[RDF-VOCAB-PUB](http://www.w3.org/TR/swbp-vocab-pub/#naming)]) are declared to be _rdfs:subPropertyOf_ those _dc:_ namespace terms [[DC-SUBPROPERTIES](http://dublincore.org/usage/decisions/2008/dcterms-changes/#sect-2)]. So if a data provider's non-RDF database contains string values for terms in the _dcterms:_ namespace having non-literal ranges, it is appropriate to expose those literals in RDF as values of corresponding _dc:_ terms.
##### 2.4.3.2 Literal values for non-literal resources in Darwin Core
##### 2.4.3.2 Literal values for non-literal resources in Darwin Core (normative)
Because there are many legacy data composed of string values of _dwc:_ namespace (http://rs.tdwg.org/dwc/terms/) terms whose objects actually represent non-literal entities (i.e., value strings sensu DCAM), it is likely that many providers will at least initially expose such data in RDF as string literals served directly from their existing databases [[RDB2RDF](http://www.w3.org/TR/r2rml/)]. To make it possible for the legacy data to be exposed as RDF while also ensuring that the meaning of those data is preserved, in RDF the literal value of an existing Darwin Core term in the _dwc:_ namespace should have the same structure as that described in the term's description, as in Example 19.
@ -768,20 +766,20 @@ Turtle
The terms in the _dwc:_ namespace should NOT be used for IRI reference objects, even if the term definition suggests that the object resource is of a non-literal type. Instead, IRI reference objects should be used with terms in the _dwciri:_ namespace as defined by this guide in [Section 2.5](./index.htm#2.5_Terms_in_the_dwciri:_namespace). When a string value is provided as the object of a _dwc:_ namespace term whose definition suggests that the object is of a non-literal type, that string is understood to be serving as a value string.
### 2.5 Terms in the dwciri: namespace
### 2.5 Terms in the dwciri: namespace (normative)
Terms in the namespace _dwciri:_ (http://rs.tdwg.org/dwc/iri/) are intended for use with IRI reference objects and should NOT be used with literal objects. They may also be used with blank node objects, although in most cases this will probably be unnecessary.
#### 2.5.1 Definition of dwciri: terms
#### 2.5.1 Definition of dwciri: terms (normative)
If a term in the _dwciri:_ namespace has a corresponding term with the same local name [[RDF-VOCAB-PUB](http://www.w3.org/TR/swbp-vocab-pub/#naming)] in the _dwc:_ namespace, the _dwciri:_ namespace term is defined to have the same meaning as its _dwc:_ namespace term analogue. In defining a _dwciri:_ term that has a _dwc:_ analogue, the definition of the _dwc:_ term is understood to be modified in the following ways:
- when a _dwciri:_ term is used as an RDF predicate, its non-literal object will be identified by an IRI reference rather than a string literal
- the object of the _dwciri:_ term predicate will be a single resource. If the _dwc:_ term definition specifies that multiple values should be a concatenated list, the resource described by a _dwciri:_ property should be the subject of a triple for each value on the list. Alternatively, a single triple can be used to describe the subject if the object is a single resource composed of component resources described using additional RDF triples.
Several terms in the _dwciri:_ namespace do not have _dwc:_ namespace analogues (_dwciri:inCollection_, _dwciri:toTaxon_, _dwciri:inDescribedPlace_, _dwciri:earliestGeochronologicalEra_, _dwciri:latestGeochronologicalEra_, _dwciri:fromLithostratigraphicUnit_, and _dwciri:inDataset_). Their definitions are given in the normative RDF for _dwciri:_ properties and are described in [Section 3.6](./index.htm#3.6_dwciri:_terms_having_local_names_that_don%E2%80%99t_correspond_to).
Several terms in the _dwciri:_ namespace do not have _dwc:_ namespace analogues (_dwciri:inCollection_, _dwciri:toTaxon_, _dwciri:inDescribedPlace_, _dwciri:earliestGeochronologicalEra_, _dwciri:latestGeochronologicalEra_, _dwciri:fromLithostratigraphicUnit_, and _dwciri:inDataset_). Their definitions are given in [Section 3.6](./index.htm#3.6_dwciri:_terms_having_local_names_that_don%E2%80%99t_correspond_to).
#### 2.5.2 Using terms in the Darwin Core dwciri: namespace with non-literal objects identified by IRI references
#### 2.5.2 Using terms in the Darwin Core dwciri: namespace with non-literal objects identified by IRI references (non-normative)
The following example shows how the data from Example 19 could be expressed if IRIs were available to identify the persons whose names composed the literal:
@ -805,11 +803,11 @@ Turtle
where <http://viaf.org/viaf/263074474> is a persistent IRI identifier for the person whose name is "Oliver P. Pearson" and <http://museum-x.org/personnel/akp> is a persistent IRI identifier for the person whose name is "Anita K. Pearson".
#### 2.5.3 Expectation of clients encountering RDF containing dwc: and dwciri: terms
#### 2.5.3 Expectation of clients encountering RDF containing dwc: and dwciri: terms (normative)
A client that encounters a triple having a term from the _dwciri:_ namespace as its predicate can expect the object of the triple to be an IRI reference and subsequently may be able to dereference that IRI to obtain additional information about the entity that it represents. A client encountering a triple having a term from the _dwc:_ namespace should be prepared to accept a literal object, although it is possible that some data providers unaware of this guide may have used _dwc:_ terms with IRI references as _rdf:resource_ attributes. Application developers should be flexible in their expectations for the values of properties from the _dwc:_ namespace.
### 2.6 Darwin Core ID terms and RDF
### 2.6 Darwin Core ID terms and RDF (normative)
Darwin Core contains a number of "ID" terms intended to designate identifiers, e.g., _dwc:occurrenceID_, _dwc:identificationID_, _dwc:locationID_, etc. The "ID" terms provide two functions, specifying the class of the resource and indicating that value of the term is an identifier. These functions are illustrated by the non-RDF XML below, which is part of an example provided in the Darwin Core XML Guide [[DWC-XML](http://rs.tdwg.org/dwc/terms/guides/xml/index.htm)]:
@ -828,7 +826,7 @@ Darwin Core contains a number of "ID" terms intended to designate identifiers, e
This example could also be represented by the following database table in which each record (row) represents an _dwc:Identification_ instance and in which each column represents a property of the _dwc:Identification_ instance as indicated by the column heading:
**Table 3**
**Table 3** (non-normative)
dwc:identificationID | dwc:identifiedBy | dwc:dateIdentified | dwc:taxonID
--- | --- | --- | ---
@ -880,7 +878,7 @@ would be valid RDF. However, best practices ([Section 2.4.2.1.1](./index.htm#2.4
4. The class of the subject identification instance (_dwc:Identification_) is asserted explicitly using _rdf:type_. The type of the object taxon instance is not stated directly - a client would need to dereference the IRI to discover it.
#### 2.6.1 Unintended consequences of using Darwin Core ID terms in RDF
#### 2.6.1 Unintended consequences of using Darwin Core ID terms in RDF (non-normative)
The previous section showed that using a Darwin Core ID term to indicate the identifier associated with the subject resource is not necessary because there are well-known means in RDF (the _rdf:about_ attribute and the _dcterms:identifier_ property) for exposing the subject’s identifier. However, as shown below, using a Darwin Core ID term to identify an object resource (as shown in the non-RDF XML Example 21) would actually be problematic. In its normative definition, each Darwin Core ID term is declared to be _rdfs:subPropertyOf_ _dcterms:identifier_. In RDF, the purpose of a subproperty declaration is to allow a client with reasoning capability to infer a triple containing a broader (and presumably more well-known) property. In the terminology of Dublin Core, the "ID" term is a qualifier which "refines" a basic Dublin Core term [[DC-QUALIFIER](http://dublincore.org/documents/usageguide/qualifiers.shtml)] and the process of inferring a broader meaning from a more specific term is called a "dumb-down" operation. If a provider attempting to expose the data of Table 3 as RDF used the _dwc:taxonID_ term as a property of the identification as shown in the (incorrect) Example 23:
@ -917,7 +915,7 @@ Subject | Predicate | Object
where the value of the _dwc:taxonID_ term was the identifier of the subject resource rather than of the object resource as intended by the data provider. This is why data providers will generally need to look outside Darwin Core for object properties that can be used to relate instances of one class to instances of another instead of using the Darwin Core ID terms.
### 2.7 Darwin Core convenience terms
### 2.7 Darwin Core convenience terms (non-normative)
In several situations, providers of Darwin Core text-based data use a set of hierarchical property/value pairs to unambiguously specify a resource. For example, a database record for a resource collected at N 36.4024°, W 87.02219° might contain the following data:
@ -929,7 +927,7 @@ dwc:decimalLatitude | dwc:decimalLongitude | dwc:geodeticDatum | dwc:continent |
The data unambiguously specifies the lowest level political subdivision (Robertson County) by including the higher level political subdivisions in the hierarchy and thus differentiates it from other places that are second-order administrative divisions identified by the string “Robertson” (e.g., Robertson County, Texas, US or Robertson County, Kentucky, US). Darwin Core terms that are used to form a hierarchy of literal values are called convenience terms.
#### 2.7.1 What purpose do convenience terms serve?
#### 2.7.1 What purpose do convenience terms serve? (non-normative)
When expressing the data about resources collected in Robertson County in RDF, it really isn’t necessary to indicate in every record that North America is a parent feature of the United States, that the United States is a parent feature of Tennessee, and that Tennessee is a parent feature of Robertson County. It is only necessary to link the record to an IRI for Robertson County such as <http://sws.geonames.org/4653638/> and a semantic client can discover the parent features by traversing the _gn:parentFeature_ property of features included in the hierarchy. Once a client has discovered the higher level parts of the hierarchy in which it is interested, no additional retrieval of data about the hierarchy is required.
@ -939,7 +937,7 @@ In general, it should not be necessary for a data provider to recreate hierarchi
- the provider may want to facilitate simple string-based queries (e.g., [[SPARQL](http://www.w3.org/TR/sparql11-query/)]) at any level of the hierarchy.
- the provider may wish to make it easier for consuming applications to create human-friendly representations of the data in which presenting the string hierarchy would be meaningful.
#### 2.7.2 Literal convenience terms versus a single object property reference
#### 2.7.2 Literal convenience terms versus a single object property reference (normative)
There are several groups of convenience terms in the _dwc:_ namespace which may be used to provide literal values for the purposes listed above ([Section 3.6](./index.htm#3.6_dwciri:_terms_having_local_names_that_don%E2%80%99t_correspond_to)). In the case of each of these groups, it is not expected that a provider will link to IRI references for each level in the hierarchy. Therefore, _dwciri:_ analogues are not defined for those convenience terms from the _dwc:_ namespace. Rather, for each category of convenience terms, there is a single _dwciri:_ namespace term (having no analogue in the _dwc:_ namespace; [Section 3.7](./index.htm#3.7_dwc:_namespace_terms_that_have_analogues_in_the_dwciri:_name)) that can be used to link to the lowest available level in the hierarchy with the understanding that the RDF of the object resource will provide links to other IRIs for higher levels of the hierarchy. Such _dwciri:_ terms can refer to any level in the hierarchy if there is uncertainty about the identity of lower levels, or if lower levels do not exist.
@ -953,11 +951,11 @@ names of geographic subdivisions (Section 2.7.5) | dwciri:inDescribedPlace | geo
chronostratographic (geological timescale) description (Section 2.7.6) | dwciri:earliestGeochronologicalEra dwciri:latestGeochronologicalEra | geochronological time period | gsml:GeochronologicEra
lithostratigraphy descriptors (Section 2.7.7) | dwciri:fromLithostratigraphicUnit | lithostratigraphic unit | not specified
#### 2.7.3 Ownership of a collection item
#### 2.7.3 Ownership of a collection item (normative)
Historically, the set of values for _dwc:institutionCode_, _dwc:collectionCode_, and _dwc:catalogNumber_ (a “Darwin Core triplet”) has been used to identify a collection item and to indicate the owning institution and collection within that institution as shown in Table 7.
**Table 7**
**Table 7** (non-normative)
dwc:basisOfRecord | dwc:institutionCode | dwc:collectionCode | dwc:catalogNumber | dwc:collectionID
--- | --- | --- | --- | ---
@ -989,7 +987,7 @@ Turtle
     dwciri:inCollection <http://biocol.org/urn:lsid:biocol.org:col:34904>.
```
#### 2.7.4 Description of a taxonomic entity
#### 2.7.4 Description of a taxonomic entity (normative)
The consensus embodied in the TDWG Taxon Concept Transfer Schema (TCS) standard [[TCS-STANDARD](http://www.tdwg.org/standards/117/)] is that identification instances refer to taxon concept instances. Therefore it would be a best practice to describe taxonomic entities in RDF as taxon concepts sensu TCS. However, because the TCS standard is an XML schema, it is not directly translatable to RDF. It is considered to be out of the scope of this document to specify how taxon concepts should be rendered as RDF. Nevertheless, Darwin Core does define many convenience terms listed under the _dwc:Taxon_ class that can be used as properties of _dwc:Identification_ instances ([Section 3.5](./index.htm#3.5_Darwin_Core_convenience_terms_that_are_expected_to_be_used_o)).
@ -997,7 +995,7 @@ It might be argued that these convenience terms would more appropriately be prop
Consider the following example where Takuma Yun identified a spider to the species _Hersilia yaeyamaensis_ using information in Tanikawa (1999). The data about this identification was listed in a database as shown in Table 8.
**Table 8**
**Table 8** (non-normative)
dwc:identificationID | dwc:identifiedBy | dwc:order | dwc:family | dwc:genus | dwc:specificEpithet | dwc:nameAccordingToID
--- | --- | --- | --- | --- | --- | ---
@ -1046,7 +1044,7 @@ should not be taken to imply that Takuma Yun asserted that the spider he identif
<http://muse.or.jp/9AC9BD26-8B41-458A-AA35-503A4527D009> dwciri:toTaxon <http://zoobank.org/75C9EA16-72B1-44C9-AD40-3C3D41323AB9>
```
#### 2.7.5 Names of geographic subdivisions
#### 2.7.5 Names of geographic subdivisions (normative)
The data from Table 5 can be expressed as shown in Example 26. In the example, the term _dwciri:inDescribedPlace_ is used as an object property to link the _dcterms:Location_ instance to an IRI for the lowest known geographic subdivision which applies to the locality. _dwc:locality_ could also be used to provide a string literal description of the specific description of the place.
@ -1084,11 +1082,11 @@ Turtle
Because generic RDF places no restrictions on repeating properties, a _dcterms:Location_ instance could have multiple _dwciri:inDescribedPlace_ properties if the location is included within several described geographic subdivisions. For example, a particular location could be included within <http://sws.geonames.org/4626068/> (The Great Smoky Mountains National Park which straddles two states) and <http://sws.geonames.org/4656568/> (Sevier County, Tennessee, US, which is the lowest level political subdivision).
#### 2.7.6 Chronostratographic (geological timescale) descriptors
#### 2.7.6 Chronostratographic (geological timescale) descriptors (normative)
The following example is taken from [http://dx.doi.org/10.1098/rsbl.2011.0228](http://dx.doi.org/10.1098/rsbl.2011.0228), which involves the geological context of a fossil serving as a holotype for a species description. In this example (Table 9), there is a single value given for the Epoch (Middle Jurassic), so the values for each of the _earliest.../latest..._ stratigraphic timescale term pairs are the same.
**Table 9**
**Table 9** (non-normative)
dwc:formation | dwc:earliestEonOrLowestEonothem dwc:latestEonOrHighestEonothem | dwc:earliestEraOrLowestErathem dwc:latestEraOrHighestErathem | dwc:earliestPeriodOrLowestSystem dwc:latestPeriodOrHighestSystem | dwc:earliestEpochOrLowestSeries dwc:latestEpochOrHighestSeries
--- | --- | --- | --- | ---
@ -1124,15 +1122,15 @@ Turtle
In this example, the object properties _dwciri:earliestGeochronologicalEra_ and _dwciri:latestGeochronologicalEra_ link to an IRI that identifies an instance of the _gsml:GeochronologicEra_ class which uses SKOS to relate the Middle Jurassic epoch to higher levels in the geochronological hierarchy.
#### 2.7.7 Lithostratigraphy descriptors
#### 2.7.7 Lithostratigraphy descriptors (normative)
Since lithostratigraphic units are hierarchical, the pattern followed with the other hierarchical convenience terms applies to the Darwin Core lithostratigraphic terms categorized under the _dwc:GeologicalContext_ class (_dwc:group_, _dwc:formation_, _dwc:member_, and _dwc:bed_). The object property _dwciri:fromLithostratigraphicUnit_ can be used to link the IRI for a lithostratigraphic unit at the lowest appropriate level.
### 2.8 Darwin Core association terms
### 2.8 Darwin Core association terms (non-normative)
Darwin Core contains a number of terms whose local name begins with "associated" (_dwc:associatedMedia_, _dwc:associatedOccurrences_, etc.), which are referred to as "association terms" in this guide. Because these terms were designed to link the subject resource to one or more related resources within a flat, text-based data system, they need special handling to represent their values as IRI-reference objects.
#### 2.8.1 What is the purpose of association terms?
#### 2.8.1 What is the purpose of association terms? (non-normative)
The information encoded by a Darwin Core association term property/value pair can be broken down into three components:
@ -1142,11 +1140,11 @@ The information encoded by a Darwin Core association term property/value pair ca
The related resource is designated by some sort of identifier present in the literal value. The type of the related resource is implied by the second part of the local name (e.g., "Media", "Occurrences", etc.). The definitions of some of the terms (_dwc:associatedTaxa_, _dwc:associatedOccurrences_, and _dwc:associatedOrganisms_) also specify that the nature of the association with the subject resource should also be included in the literal value ("sibling of", "predator of ", etc.).
#### 2.8.2 Expressing Darwin Core association terms as RDF with literal values
#### 2.8.2 Expressing Darwin Core association terms as RDF with literal values (normative)
A database might contain the information shown in Table 10.
**Table 10**
**Table 10** (non-normative)
dwc:organismID | dwc:associatedOrganisms | dwc:associatedMedia
--- | --- | ---
@ -1178,7 +1176,7 @@ Because the values of the association terms are literals, a consuming client wou
The advantage of presenting the literal values of Darwin Core association properties via RDF as in Example 28 is that a provider could easily expose existing data with little effort. The disadvantage is that there would be a significant processing burden on consuming clients. It is possible that some literal values would be uninterpretable without additional information from another source. For example, how can the organism identified by "AX3467" be distinguished globally from other organisms that might have also been assigned the identifier "AX3467" ?
#### 2.8.3 Expressing Darwin Core association terms as RDF with URI references
#### 2.8.3 Expressing Darwin Core association terms as RDF with URI references (normative)
Because a Darwin Core association term property/value pair actually encodes two or more discrete "facts", it is probably better to represent the information contained in that property/value pair by more than a single triple.
@ -1238,7 +1236,7 @@ Notes:
1. Because there is no well-known term for expressing the relationship "sibling of", the nature of the relation between the two associated organisms was not represented in the triples.
2. In this example, both of the associated media items were depictions of the subject organism, so _foaf:depiction_ was used to indicate that. However, it is likely that many associated media items will not depict the subject resource. For example, specimen labels do not depict specimens with which they are associated nor do still images of habitats depict organisms with which they are associated. Therefore, there is a need for more expressive terms to describe these types of relations more precisely. However, creating such terms is beyond the scope of this guide.
#### 2.8.4 Querying for associated resources
#### 2.8.4 Querying for associated resources (non-normative)
If the strategy outlined in [Section 2.8.3](./index.htm#2.8.3_Expressing_Darwin_Core_association_terms_as_RDF_with_URI_r) were used, resources associated with a subject resource could be discovered using a SPARQL query [[SPARQL](http://www.w3.org/TR/sparql11-query/)] similar to Example 30. In that example, <iri1> is the IRI of a subject resource, and _dcmitype:StillImage_ is the type of associated media that would be discovered.
@ -1254,7 +1252,7 @@ PREFIX dcmitype: <http://purl.org/dc/dcmitype/>SELECT ?resource WHERE {
 }
```
### 2.9 MeasurementOrFact instances
### 2.9 MeasurementOrFact instances (normative)
Darwin Core provides a mechanism for expressing measurements and factual information associated with resources that are described using Darwin Core. Terms from the _dwc:_ namespace that are organized in the _dwc:MeasurementOrFact_ class were designed to express this information using string values in "flat" files. The information can be also expressed as RDF using a combination of literal value _dwc:_ namespace terms and IRI value _dwciri:_ terms. It is likely that this information could also be mapped to more expressive terms. However, that sort of translation is beyond the scope of this guide.
@ -1288,11 +1286,11 @@ Turtle
          dwc:measurementRemarks "Accuracy from significant digits."@en].
```
## 3 Term reference
## 3 Term reference (normative)
This section organizes terms from Darwin Core and other key vocabularies according to their use in RDF. If the use of a term has additional restrictions or implications (e.g., domain and range assertions), they are noted. Recommended formats and values are given when appropriate.
### 3.1 Non-Darwin Core terms needed to express fundamental properties in RDF
### 3.1 Non-Darwin Core terms needed to express fundamental properties in RDF (normative)
term | Notes
--- | ---
@ -1300,7 +1298,7 @@ rdf:type | Used to indicate the class of which the resource is an instance. It i
dcterms:identifier | Used to relate string literal identifiers to the subject resource. This can include string representations of IRIs if they are considered the identifier for the resource.
dcterms:relation | Used to link subject and object resources that have an unspecified association.
### 3.2 Imported Dublin Core terms for which only literal objects are appropriate
### 3.2 Imported Dublin Core terms for which only literal objects are appropriate (normative)
term | domain | range
--- | --- | ---
@ -1309,7 +1307,7 @@ dcterms:bibliographicCitation | dcterms:BibliographicResource | rdfs:Literal
[^1]: Recommended format is ISO 8601:2004(E) [[ISO-DATES](http://en.wikipedia.org/wiki/ISO_8601)]. See notes on date terms in [Section 3.4](./index.htm#3.4_Terms_defined_by_Darwin_Core_that_are_expected_to_be_used_on) for further information.
### 3.3 Imported Dublin Core terms that have non-literal objects and corresponding terms that have literal objects
### 3.3 Imported Dublin Core terms that have non-literal objects and corresponding terms that have literal objects (normative)
Term intended for use in RDF with non-literal objects[^2] | range | recommended values[^3] | Term intended for use in RDF with literal objects
dcterms:language | dcterms:LinguisticSystem | MARC ISO 639-2 language IRI | dc:language
@ -1331,7 +1329,7 @@ dcterms:references | --- | IRI for a publication (preferably an HTTP-proxied DOI
[^7]: See the DCMI accessRights guidelines [[DC-ACCESSRIGHTS](http://wiki.dublincore.org/index.php/User_Guide/Publishing_Metadata#dcterms:accessRights)] for an example.
### 3.4 Terms defined by Darwin Core that are expected to be used only with literal values
### 3.4 Terms defined by Darwin Core that are expected to be used only with literal values (normative)
Darwin Core term | Notes on expressing as RDF
--- | ---
@ -1344,9 +1342,9 @@ dwc:otherCatalogNumbers | There is no simple mapping because of the kinds of ide
dwc:basisOfRecord | Use only with literal value strings consisting of the local name component of Darwin Core class IRIs. Use rdf:type to refer to IRIs that describe the type of the resource.
dwc:dynamicProperties | Expected to contain JSON as a literal. Communities of practice might choose to use other vocabularies or develop their own vocabularies to express this sort of content directly as RDF.
[^8]: No Darwin Core terms defined in the Darwin Core normative RDF (as opposed to those imported from Dublin Core) have domain or range declarations as a part of their definitions. However, the five terms in the _dwc:_ namespace listed in the table above are defined to be _rdfs:subPropertyOf_ of _dcterms:date_, which has the range _rdfs:Literal_. Under the extensional entailment rule ext4 listed in section 7.3.1 of the RDF Semantics 2004 W3C Recommendation [[RDF-SEMANTICS-2004](http://www.w3.org/TR/2004/REC-rdf-mt-20040210/#RDFSExtRules)], these terms can be inferred to have the range _rdfs:Literal_. However, the RDF 1.1 Semantics W3C Recommendation [[RDF-SEMANTICS-1.1](http://www.w3.org/TR/rdf11-mt/)] does not include these extensional entailment rules. Nevertheless, it is reasonable to expect that date properties should have literal values, with datatype attributes whenever possible.
[^8]: No Darwin Core terms defined by Darwin Core (as opposed to those imported from Dublin Core) have domain or range declarations as a part of their definitions. However, the five terms in the _dwc:_ namespace listed in the table above are defined to be _rdfs:subPropertyOf_ of _dcterms:date_, which has the range _rdfs:Literal_. Under the extensional entailment rule ext4 listed in section 7.3.1 of the RDF Semantics 2004 W3C Recommendation [[RDF-SEMANTICS-2004](http://www.w3.org/TR/2004/REC-rdf-mt-20040210/#RDFSExtRules)], these terms can be inferred to have the range _rdfs:Literal_. However, the RDF 1.1 Semantics W3C Recommendation [[RDF-SEMANTICS-1.1](http://www.w3.org/TR/rdf11-mt/)] does not include these extensional entailment rules. Nevertheless, it is reasonable to expect that date properties should have literal values, with datatype attributes whenever possible.
### 3.5 Darwin Core convenience terms that are expected to be used only with literal values
### 3.5 Darwin Core convenience terms that are expected to be used only with literal values (normative)
See [Section 2.7](./index.htm#2.7_Darwin_Core_convenience_terms) for more information on "convenience" terms.
@ -1358,7 +1356,7 @@ dwc:higherGeography</br>dwc:continent</br>dwc:waterBody</br>dwc:islandGroup</br>
dwc:earliestEonOrLowestEonothem</br>dwc:latestEonOrHighestEonothem</br>dwc:earliestEraOrLowestErathem</br>dwc:latestEraOrHighestErathem</br>dwc:earliestPeriodOrLowestSystem</br>dwc:latestPeriodOrHighestSystem</br>dwc:earliestEpochOrLowestSeries</br>dwc:latestEpochOrHighestSeries</br>dwc:earliestAgeOrLowestStage</br>dwc:latestAgeOrHighestStage | The subject resource should be a dwc:GeologicalContext instance. As an alternative, use the object properties dwciri:earliestGeochronologicalEra and dwciri:latestGeochronologicalEra as described in Section 3.6. See Section 2.7.6 for details.
dwc:lithostratigraphicTerms</br>dwc:group</br>dwc:formation</br>dwc:member</br>dwc:bed | The subject resource should be a dwc:GeologicalContext instance. As an alternative, use the object property dwciri:fromLithostratigraphicUnit to link the subject resource to the lowest appropriate unit of a lithostratigraphic hierarchy.
### 3.6 dwciri: terms having local names that don’t correspond to terms in the dwc: Darwin Core namespace
### 3.6 dwciri: terms having local names that don’t correspond to terms in the dwc: Darwin Core namespace (normative)
Darwin Core term | Notes
--- | ---
@ -1369,7 +1367,7 @@ dwciri:earliestGeochronologicalEra</br>dwciri:latestGeochronologicalEra | Use to
dwciri:fromLithostratigraphicUnit | Use to link a dwc:GeologicalContext instance to an IRI-identified lithostratigraphic unit at the lowest possible level in a hierarchy. It is expected that such resources will be linked to higher levels in the hierarchy by the organization minting the IRI. See Section 2.7.7 for usage details.
dwciri:inDataset | This object property is provided to link a subject dataset record to the dataset which contains it. A string literal name of the dataset can be provided using the term dwc:datasetName.
### 3.7 dwc: namespace terms that have analogues in the dwciri: namespace
### 3.7 dwc: namespace terms that have analogues in the dwciri: namespace (normative)
Darwin Core term having a dwciri: analogue with the same local name | Notes on the dwciri: analogues
--- | ---
@ -1381,7 +1379,7 @@ dwc:informationWithheld</br>dwc:dataGeneralizations</br>dwc:habitat | If the obj
dwc:fieldNumber</br>dwc:fieldNotes | dwciri:fieldNumber is an object property whose subject is a (possibly IRI-identified) resource that is the field notes and whose object is a dcmitype:Event instance. dwciri:fieldNotes is an object property whose subject is a dcmitype:Event instance and whose object is a (possibly IRI-identified) resource that is the field notes.
dwc:recordNumber | dwciri:recordNumber is an object property whose subject is an occurrence and and whose object is a (possibly IRI-identified) resource that is the field notes.
### 3.8 Darwin Core terms for which this guide does not recommend the use of a dwciri: object property
### 3.8 Darwin Core terms for which this guide does not recommend the use of a dwciri: object property (normative)
Darwin Core term | Notes
--- | ---

19
docs/simple/index.md
View File

@ -35,12 +35,14 @@ Bibliographic citation
## 1 Introduction
**Audience**: This document is targeted toward those who want to share biodiversity information using the simplest methods and structure: Simple Darwin Core. It explains the uses and limitations of this structure and how to expand upon it.
## 2 What is Simple Darwin Core?
Simple Darwin Core is a predefined subset of the terms that have common use across a wide variety of biodiversity applications. The terms used in Simple Darwin Core are those that are found at the cross-section of taxonomic names, places, and events that document biological occurrences on the planet. The two driving principles are simplicity and flexibility.
### 1.1 Status of the content of this document
All sections of this document are normative, except for examples, which are explicitly marked as non-normative.
## 2 Audience
This document is targeted toward those who want to share biodiversity information using the simplest methods and structure: Simple Darwin Core. It explains the uses and limitations of this structure and how to expand upon it.
## 3 What makes it simple?
Simple Darwin Core is simple in that it assumes (and allows) no structure beyond the concept of rows and columns, which might be thought of as attributes and their values, or fields and records. The words field and record will be used throughout the rest of the document to refer to the two dimensions of the Simple Darwin Core structure. Think of the term names as the field names. In other words, a Simple Darwin Core record could be captured in a spreadsheet or in a single database table.
@ -80,7 +82,10 @@ The [Text guide](../text/) describes how to construct and format a text file usi
### 6.2 Simple Darwin Core as XML
The [XML guide](../xml/) describes how to construct XML schemas to share data based on Darwin Core terms. Looking at the [Simple Darwin Core XML Schema](../xml/tdwg_dwc_simple.xsd) using the XML guide as a reference you will be able to see that the schema supports the notion of a `SimpleDarwinRecord`, which is just a grouping of up to one of each of the Darwin Core terms that are `Properties` (not `Classes`). The following example shows a `SimpleDarwinRecordSet` containing one `SimpleDarwinRecord` for a `Taxon`:
The [XML guide](../xml/) describes how to construct XML schemas to share data based on Darwin Core terms. Looking at the [Simple Darwin Core XML Schema](../xml/tdwg_dwc_simple.xsd) using the XML guide as a reference you will be able to see that the schema supports the notion of a `SimpleDarwinRecord`, which is just a grouping of up to one of each of the Darwin Core terms that are `Properties` (not `Classes`).
#### 6.2.1 Example of Simple Darwin Core as XML (non-normative)
The following example shows a `SimpleDarwinRecordSet` containing one `SimpleDarwinRecord` for a `Taxon`:
```xml
<?xml version="1.0" encoding="UTF-8"?>
@ -131,8 +136,11 @@ Sooner or later you may want to share more information than Simple Darwin Core s
One way would be to try to "overload" existing terms by using them to hold information other than what was intended based on the definition of the terms. Please don't do this. If an existing term has close to the same meaning as one you want to use, but just doesn't quite fit because of the way the definition is worded, it would be better to request an amendment to the term definition so that it will be clear for your community how to use it. You can request such a change by submitting an issue in the [Darwin Core repository](https://github.com/tdwg/dwc).
### 7.1 Structured content using dynamicProperties
Another way to get more out of Darwin Core without adding a term is to "payload" the [`dynamicProperties`](http://rs.tdwg.org/dwc/terms/dynamicProperties) term with structured content, as shown in the example below, using Javascript Open Notation (JSON). This is perfectly legal, since it doesn't compromise the meaning of the term. One of the weaknesses of payloading data in this way is that it is subject to a lack of stable or well-defined semantics. Also, it is highly recommended to flatten the content into a single string with no non-printing characters (such as line feeds) to facilitate use in the widest variety of data sharing contexts. Still, this might be a reasonable way to at least allow you to share all of your data, even if there might be problems with people using it reliably.
#### 7.1.1 Example of structured JSON content within XML (non-normative)
```xml
<?xml version="1.0" encoding="UTF-8"?>
<SimpleDarwinRecordSet
@ -166,6 +174,7 @@ Another way to get more out of Darwin Core without adding a term is to "payload"
</SimpleDarwinRecordSet>
```
### 7.2 Extending Darwin Core by adding terms
If you were using just CSV text files to exchange information, then you might be tempted to just add the new fields to the files. This approach suffers most of the same problems as payloading - no one aside from those with whom you communicated would know what those new fields were or how to use them. Sharing in this way via XML would be an even bigger problem, because the [Simple Darwin Core XML Schema](../xml/tdwg_dwc_simple.xsd) defines the terms that it supports and the new fields would not correspond with any terms understood by the schema. In other words, the XML with your fields in it would not be a valid Simple Darwin Core XML document.
So, if you really need to extend the capabilities of Darwin Core, the best first step is to follow the standards process to add the terms you need. See the [Contributing guide](https://github.com/tdwg/dwc/blob/master/.github/CONTRIBUTING.md) to understand how to suggest a new term.

82
docs/text/index.md
View File

@ -3,11 +3,23 @@
Title
: Darwin Core text guide
Date Issued
Date version issued
: 2015-06-02
Date created
: 2009-02-12
Date Modified
: 2015-06-02
Part of TDWG Standard
: <http://www.tdwg.org/standards/450/>
This version
: <http://rs.tdwg.org/dwc/terms/guides/text/2014-11-08>
Latest version
: <http://rs.tdwg.org/dwc/terms/guides/text/>
Previous version
: <http://rs.tdwg.org/dwc/terms/guides/text/2009-12-07>
Abstract
: Guidelines for implementing Darwin Core in Text files.
@ -15,26 +27,11 @@ Abstract
Contributors
: Tim Robertson (GBIF), Markus Döring (GBIF), John Wieczorek (MVZ), Renato De Giovanni (CRIA), Dave Vieglais (KUNHM)
Legal
: This document is governed by the standard legal, copyright, licensing provisions and disclaimers issued by the Taxonomic Databases Working Group.
Part of TDWG Standard
: <http://www.tdwg.org/standards/450/>
Creator
: Darwin Core Task Group
Identifier
: <http://rs.tdwg.org/dwc/2014-11-08/terms/guides/text/>
Latest Version
: <http://rs.tdwg.org/dwc/terms/guides/text/>
Replaces
: <http://rs.tdwg.org/dwc/2009-12-07/terms/guides/text/>
Document Status
: Current Standard
Bibliographic citation
: Darwin Core Task Group. 2009. Darwin Core text guide. Biodiversity Information Standards (TDWG). http://rs.tdwg.org/dwc/terms/guides/text/
## 1 Introduction
@ -44,14 +41,17 @@ This document provides guidelines for formatting and sharing [Darwin Core terms]
More complex structure can be shared in multiple related files. The description of content and relationships between files can be achieved using the metafile. This guideline makes recommendations for the simple case of a _core_ file, upon which Darwin Core _records_ are based, and _extensions_ that are linked to records in that core file. Specifically, extension records have a _many-to-one_ relationship with records in the core file. For example, a core file might contain specimen records, with one specimen per row in the file, while an extension file contains one or more identifications for those specimens, with one identification per row in the extension file, and with an identifier to the specimen for each identification row. This example would allow many identifications to be associated with each specimen.
### 1.1 Simple example metafile content
### 1.1 Status of the content of this document
All sections of this document are normative, except for examples, whose sections are marked as non-normative.
### 1.2 Simple example metafile content (non-normative)
A simple comma separated values (CSV) data file with the following content:
```csv
ID,Species,Count
123,"Cryptantha gypsophila Reveal & C.R. Broome",12
124,"Buxbaumia piperi",2
124,"Buxbaumia piperi",2
```
can be described with the following Darwin Core metafile:
@ -83,7 +83,7 @@ PhysicalObject,ANSP,PH,123,"Cryptantha gypsophila Reveal & C.R. Broome",12,urn:l
PhysicalObject,ANSP,PH,124,"Buxbaumia piperi",2,urn:lsid:tim.lsid.tdwg.org:collections:1
```
### 1.2 XML versus fielded text
### 1.3 XML versus fielded text
Many resources exist on the web describing the advantages of Extensible Markup Language [XML](http://www.w3.org/XML/) over less structured content such as _fielded text_. The Darwin Core text guide (this document) is not meant to promote the use of fielded text over XML for data exchange, but rather to provide recommendations for how to handle such data files when necessary.
@ -104,7 +104,7 @@ The `<archive>` element is the container for the list of related files (one core
Attribute | Description | Required | Default
--- | --- | --- | ---
`metadata` | Contains a qualified Uniform Resource Locator (URL) defining the location of a metadata description of the entire archive. The format of the metadata is not prescribed, but a standardized format such as Ecological Metadata Language (EML), Federal Geographic Data Committee (FGDC), or ISO 19115 family is recommended. | no |
`metadata` | Contains a qualified Uniform Resource Locator (URL) defining the location of a metadata description of the entire archive. The format of the metadata is not prescribed, but a standardized format such as Ecological Metadata Language (EML), Federal Geographic Data Committee (FGDC), or ISO 19115 family is recommended. | no |
#### 2.1.2 Elements
@ -119,7 +119,7 @@ Element | Description
Attribute | Description | Required | Default
--- | --- | --- | ---
`rowType` | A Unified Resource Identifier (URI) for the term identifying the class of data represented by each row, for example, http://rs.tdwg.org/dwc/terms/Occurrence for Occurrence records or http://rs.tdwg.org/dwc/terms/Taxon for Taxon records. Additional classes may be referenced by URI and defined outside the Darwin Core specification. The row type is required. For convenience the URIs for classes defined by the Darwin Core are listed below: <dl><dt>Occurrence</dt><dd>http://rs.tdwg.org/dwc/terms/Occurrence</dd><dt>Event</dt><dd>http://rs.tdwg.org/dwc/terms/Event</dd><dt>Location</dt><dd>http://purl.org/dc/terms/Location</dd><dt>GeologicalContext</dt><dd>http://purl.org/dc/terms/GeologicalContext</dd><dt>Identification</dt><dd>http://rs.tdwg.org/dwc/terms/Identification</dd><dt>Taxon</dt><dd>http://rs.tdwg.org/dwc/terms/Taxon</dd><dt>ResourceRelationship</dt><dd>http://rs.tdwg.org/dwc/terms/ResourceRelationship</dd><dt>MeasurementOrFact</dt><dd>http://rs.tdwg.org/dwc/terms/MeasurementOrFact</dd></dl> | yes |
`rowType` | A Unified Resource Identifier (URI) for the term identifying the class of data represented by each row, for example, http://rs.tdwg.org/dwc/terms/Occurrence for Occurrence records or http://rs.tdwg.org/dwc/terms/Taxon for Taxon records. Additional classes may be referenced by URI and defined outside the Darwin Core specification. The row type is required. For convenience the URIs for classes defined by the Darwin Core are listed below: <dl><dt>Occurrence</dt><dd>http://rs.tdwg.org/dwc/terms/Occurrence</dd><dt>Event</dt><dd>http://rs.tdwg.org/dwc/terms/Event</dd><dt>Location</dt><dd>http://purl.org/dc/terms/Location</dd><dt>GeologicalContext</dt><dd>http://purl.org/dc/terms/GeologicalContext</dd><dt>Identification</dt><dd>http://rs.tdwg.org/dwc/terms/Identification</dd><dt>Taxon</dt><dd>http://rs.tdwg.org/dwc/terms/Taxon</dd><dt>ResourceRelationship</dt><dd>http://rs.tdwg.org/dwc/terms/ResourceRelationship</dd><dt>MeasurementOrFact</dt><dd>http://rs.tdwg.org/dwc/terms/MeasurementOrFact</dd></dl> | yes |
`fieldsTerminatedBy` | Specifies the delimiter between fields. Typical values might be `,` or `\t` for CSV or Tab files respectively. | no | `,`
`linesTerminatedBy` | Specifies the row separator character. | no | `\n`
`fieldsEnclosedBy` | Specifies the character used to enclose (mark the start and end of) each field. CSV files frequently use the double quote character (`"`), but the default is no enclosing character. Note that a comma separated value file that has commas within the content of any field must have an enclosing character. | no | `"`
@ -154,14 +154,14 @@ The field element is used to specify the location and content of data within a f
Attribute | Description | Required | Default
--- | --- | --- | ---
`index` | Specifies the position of the column in the row. The first column has an index of 0, the second column 1, etc. If no column index is specified, then the term and the default may be used to define a constant value for all rows. | no |
`term` | A Unified Resource Identifier (URI) for the term represented by this field. For example, a field containing the scientific name would have `term="http://rs.tdwg.org/dwc/terms/scientificName"`. Terms outside of the Darwin Core specification may be used, such as those from the Dublin Core Metadata Initative, for example, `dcterms:modified` would be `term="http://purl.org/dc/terms/modified"`. | yes |
`default` | Specifies value to use if one is not supplied for the field in a given row. If no index is supplied, the default can be used to define a constant for all rows for a field that is not in the data file. | no |
`vocabulary` | A Unified Resource Identifier (URI) for a vocabulary that the source values for this field are based on. The URI ideally should resolve to some machine readable definition like SKOS, RDF or at least some simple text or html file often found for ISO or RFC standards. For example http://rs.gbif.org/vocabulary/gbif/nomenclatural_code.xml, http://www.ietf.org/rfc/rfc3066.txt or http://www.iso.org/iso/list-en1-semic-3.txt. | no |
`index` | Specifies the position of the column in the row. The first column has an index of 0, the second column 1, etc. If no column index is specified, then the term and the default may be used to define a constant value for all rows. | no |
`term` | A Unified Resource Identifier (URI) for the term represented by this field. For example, a field containing the scientific name would have `term="http://rs.tdwg.org/dwc/terms/scientificName"`. Terms outside of the Darwin Core specification may be used, such as those from the Dublin Core Metadata Initative, for example, `dcterms:modified` would be `term="http://purl.org/dc/terms/modified"`. | yes |
`default` | Specifies value to use if one is not supplied for the field in a given row. If no index is supplied, the default can be used to define a constant for all rows for a field that is not in the data file. | no |
`vocabulary` | A Unified Resource Identifier (URI) for a vocabulary that the source values for this field are based on. The URI ideally should resolve to some machine readable definition like SKOS, RDF or at least some simple text or html file often found for ISO or RFC standards. For example http://rs.gbif.org/vocabulary/gbif/nomenclatural_code.xml, http://www.ietf.org/rfc/rfc3066.txt or http://www.iso.org/iso/list-en1-semic-3.txt. | no |
## 3 Implementation guide
### 3.1 Extension example
### 3.1 Extension example (non-normative)
The following example illustrates the use of extensions. In this example there are three files in the archive, all of which are located in the same directory as the metafile. The whales.txt file acts as a core file of Taxon records. The whales.txt file is extended by two other files, types.txt and distribution.txt. The types.txt file contains records of a type specified in an external definition at http://http://rs.gbif.org/terms/1.0/Types and consists of Dublin Core and Darwin Core terms, while the distribution.txt file contains records of a type specified at http://http://rs.gbif.org/terms/1.0/Distribution and consists of Darwin Core terms plus an additional term for threatStatus. Both extension files are related to the core file by the taxonNameID fields. Presumably, this archive contains information about whale species, type specimen records for those species, and lists of countries and the threat status for those species.
@ -173,7 +173,7 @@ The following example illustrates the use of extensions. In this example there a
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xsi:schemaLocation="http://rs.tdwg.org/dwc/text/ http://rs.tdwg.org/dwc/text/tdwg_dwc_text.xsd">
<core encoding="UTF-8" fieldsTerminatedBy="\t" linesTerminatedBy="\n" ignoreHeaderLines="1" rowType="http://rs.tdwg.org/dwc/terms/Taxon">
<files>
<location>whales.txt</location>
@ -186,7 +186,7 @@ The following example illustrates the use of extensions. In this example there a
<field index="4" term="http://rs.tdwg.org/dwc/terms/parentNameUsageID"/>
<field index="5" term="http://rs.tdwg.org/dwc/terms/originalNameUsageID"/>
</core>
<extension encoding="UTF-8" fieldsTerminatedBy="," linesTerminatedBy="\n" fieldsEnclosedBy='"' ignoreHeaderLines="1" rowType="http://rs.gbif.org/terms/1.0/Types">
<files>
<location>types.csv</location>
@ -198,7 +198,7 @@ The following example illustrates the use of extensions. In this example there a
<field index="4" term="http://rs.tdwg.org/dwc/terms/institutionCode"/>
<field index="5" term="http://rs.tdwg.org/dwc/terms/typeStatus"/>
</extension>
<extension encoding="UTF-8" fieldsTerminatedBy="," linesTerminatedBy="\n" fieldsEnclosedBy='"' ignoreHeaderLines="1" rowType="http://rs.gbif.org/terms/1.0/Distribution">
<files>
<location>distribution.csv</location>
@ -211,19 +211,19 @@ The following example illustrates the use of extensions. In this example there a
</archive>
```
## 4 Database example
## 4 Database example (non-normative)
### 4.1 MySQL
It is very easy to produce fielded text using the `SELECT INTO` outfile command from MySQL. The encoding of the resulting file will depend on the server variables and collations used, and might need to be modified before the operation is done. Note that MySQL will export `NULL` values as `\N` by default. Use the `IFNULL()` function as shown in the following example to avoid this.
```SQL
SELECT
IFNULL(id, ''), IFNULL(scientific_name, ''), IFNULL(count,'')
INTO outfile '/tmp/dwc.txt'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM
SELECT
IFNULL(id, ''), IFNULL(scientific_name, ''), IFNULL(count,'')
INTO outfile '/tmp/dwc.txt'
FIELDS TERMINATED BY ','
OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM
dwc;
```

51
docs/xml/index.md
View File

@ -3,11 +3,23 @@
Title
: Darwin Core XML guide
Date Issued
Date version issued
: 2015-06-02
Date created
: 2009-02-12
Date Modified
: 2015-06-02
Part of TDWG Standard
: <http://www.tdwg.org/standards/450/>
This version
: <http://rs.tdwg.org/dwc/terms/guides/xml/2014-11-08>
Latest version
: <http://rs.tdwg.org/dwc/terms/guides/xml/>
Previous version
: <http://rs.tdwg.org/dwc/terms/guides/xml/2010-05-23>
Abstract
: Guidelines for the implementation of Darwin Core in XML.
@ -15,35 +27,24 @@ Abstract
Contributors
: John Wieczorek (MVZ), Markus Döring (GBIF), Renato De Giovanni (CRIA), Tim Robertson (GBIF), Dave Vieglais (KUNHM)
Legal
: This document is governed by the standard legal, copyright, licensing provisions and disclaimers issued by the Taxonomic Databases Working Group.
Part of TDWG Standard
: <http://www.tdwg.org/standards/450/>
Creator
: Darwin Core Task Group
Identifier
: <http://rs.tdwg.org/dwc/2014-11-08/terms/guides/xml/>
Latest Version
: <http://rs.tdwg.org/dwc/terms/guides/xml/>
Replaces
: <http://rs.tdwg.org/dwc/2010-05-23/terms/guides/xml/>
Document Status
: Current Standard
Bibliographic citation
: Darwin Core Task Group. 2009. Darwin Core XML guide. Biodiversity Information Standards (TDWG). http://rs.tdwg.org/dwc/terms/guides/xml/
## 1 Introduction
**Audience**: This document is targeted toward those who wish to use or construct application schemas using Darwin Core terms in XML. It includes explanations of existing schemas such as [Simple Darwin Core](../simple/) and how to build new schemas to meet specific models of information.
This document provides guidelines for implementing application schemas based on [Darwin Core terms](../../terms/) using [XML](http://www.w3.org/XML/). The underlying metadata model is described (in a syntax neutral way), followed by some specific guidelines for XML implementations. Some guidance on the use of non-Darwin Core terms is also provided.
This document does not provide guidelines for encoding Darwin Core in RDF/XML. Nor does it take a position on the relative merits of encoding metadata in "plain" XML rather than RDF/XML. This document provides guidelines in those cases where RDF/XML is not considered appropriate.
### 1.1 Status of the content of this document
All sections of this document are normative, except for sections that are explicitly marked as non-normative.
### 1.2 Audience
This document is targeted toward those who wish to use or construct application schemas using Darwin Core terms in XML. It includes explanations of existing schemas such as [Simple Darwin Core](../simple/) and how to build new schemas to meet specific models of information.
## 2 Implementation guide
### 2.1 XML schema
@ -103,6 +104,7 @@ Do not use an empty string - an element with no content:
The term [`dcterms:type`](http://rs.tdwg.org/dwc/terms/dcterms:type) (which is controlled by the [Dublin Core Type Vocabulary](http://dublincore.org/documents/dcmi-type-vocabulary/)), gives the basic category of object (`PhysicalObject`, `StillImage`, `MovingImage`, `Sound`, `Text`) the record is about. The term [`basisOfRecord`](http://rs.tdwg.org/dwc/terms/basisOfRecord), which has a controlled vocabulary distinct from that of `dcterms:type`, shows the name of the Darwin Core class (e.g., [`LivingSpecimen`](http://rs.tdwg.org/dwc/terms/LivingSpecimen), [`PreservedSpecimen`](http://rs.tdwg.org/dwc/terms/PreservedSpecimen), [`FossilSpecimen`](http://rs.tdwg.org/dwc/terms/FossilSpecimen), [`HumanObservation`](http://rs.tdwg.org/dwc/terms/HumanObservation), [`MachineObservation`](http://rs.tdwg.org/dwc/terms/MachineObservation), [`Taxon`](http://rs.tdwg.org/dwc/terms/Taxon)) the record is about.
#### 2.6.1 Simple Darwin Core example (non-normative)
Following is a brief example of an XML document for a single specimen complying with the [Simple Darwin Core Schema](tdwg_dwc_simple.xsd)]. The [Simple Darwin Core XML example document](example_simple.xml) (if this link shows a blank page in your browser, use the View Source option to see the XML document) shows detail for a single record having a more complete set of elements.
```xml
@ -137,7 +139,10 @@ Many Darwin Core terms (`properties`) are defined as being associated with anoth
- [Terms XML Schema](tdwg_dwcterms.xsd) - property term definitions as typed global elements and named groups for all terms for a given class to be referenced. The schema makes use of substitution groups `anyClass`, `anyProperty`, `anyIdentifier` and `anyXYZTerm` for each class, e.g. `anyTaxonTerm`. This is the schema upon which the [Simple Darwin Core XML Schema](tdwg_dwc_simple.xsd) is based.
- [Class Terms XML Schema](tdwg_dwc_class_terms.xsd) - class term definitions as typed global elements with subelements referencing all corresponding property terms via their substitution group.
It is encouraged to use classes in a normalized way to avoid deep nesting. A [Darwin Core Tools and Applications page](https://github.com/tdwg/dwc-documentation/blob/master/documentation/resources.md) has been created as an index to example schemas for the purpose of community discussions and development. An [XML schema](tdwg_dwc_classes.xsd) is provided to freely mix any Darwin Core Class in a global list and allow them to reference each other using the respective class identifier terms. Following is an example of using normalized classes to represent two related specimen occurrences (one of which has had a second identification) at one location following this class-based schema. Note that you can reuse the location definition here by referring to it via locationID:
It is encouraged to use classes in a normalized way to avoid deep nesting. A [Darwin Core Tools and Applications page](https://github.com/tdwg/dwc-documentation/blob/master/documentation/resources.md) has been created as an index to example schemas for the purpose of community discussions and development. An [XML schema](tdwg_dwc_classes.xsd) is provided to freely mix any Darwin Core Class in a global list and allow them to reference each other using the respective class identifier terms.
#### 2.7.1 Normalized classes examples (non-normative)
Following is an example of using normalized classes to represent two related specimen occurrences (one of which has had a second identification) at one location following this class-based schema. Note that you can reuse the location definition here by referring to it via locationID:
```xml
<?xml version="1.0"?>