PROV-N: The Provenance Notation

Internal Release Version (Diffs since last release)

W3C Editor's Draft 14 June 2012

This version:: http://dvcs.w3.org/hg/prov/raw-file/default/model/prov-n.html
Latest published version:: http://www.w3.org/TR/prov-n/
Latest editor's draft:: http://dvcs.w3.org/hg/prov/raw-file/default/model/prov-n.html
Previous version:: http://www.w3.org/TR/2012/WD-prov-n-20120503/
Editors:: Luc Moreau, University of Southampton; Paolo Missier, Newcastle University

Abstract

PROV-DM, the PROV conceptual data model, is a data model for provenance that describes the entities, people and activities involved in producing a piece of data or thing. PROV-DM distinguishes core structures, forming the essence of provenance descriptions, from extended structures catering for more advanced uses of provenance. PROV-DM is organized in six components, respectively dealing with: (1) entities and activities, and the time at which they were created, used, or ended; (2) agents bearing responsibility for entities that were generated and activities that happened; (3) derivations of entities from entities; (4) properties to link entities that refer to the same thing; (5) a notion of bundle, a mechanism to support provenance of provenance; and, (6) collections forming a logical structure for its members.

To provide examples of the PROV data model, the PROV notation (PROV-N) is introduced: aimed at human consumption, PROV-N allows serializations of PROV instances to be created in a compact manner. PROV-N facilitates the mapping of the PROV data model to concrete syntax, and is used as the basis for a formal semantics of PROV. The purpose of this document is to define the PROV-N notation.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

Intended to be Last Call (TBC)

This is the fifth public release of the PROV-DM document. Publication as Last Call working draft means that the Working Group believes that it has satisfied the relevant technical requirements outlined in its charter on this document. The design is not expected to change significantly, going forward, and now is the key time for external review, before the implementation phase.

Please Comment By (date TBD)

The PROV Working group seeks public feedback on this Working Draft. The end date of the Last Call review period is TBD, and we would appreciate comments by that date to public-prov-comments@w3.org

PROV Family of Specifications

This document is part of the PROV family of specifications, a set of specifications defining various aspects that are necessary to achieve the vision of inter-operable interchange of provenance information in heterogeneous environments such as the Web. The specifications are:

PROV-DM, the PROV data model for provenance;
PROV-CONSTRAINTS, a set of constraints applying to the PROV data model;
PROV-N, a notation for provenance aimed at human consumption (this document);
PROV-O, the PROV ontology, an OWL-RL ontology allowing the mapping of PROV to RDF;
PROV-AQ, the mechanisms for accessing and querying provenance;
PROV-PRIMER, a primer for the PROV data model;
PROV-SEM, a formal semantics for the PROV data model;
PROV-XML, an XML schema for the PROV data model.

How to read the PROV Family of Specifications

The primer is the entry point to PROV offering an introduction to the provenance model.
The Linked Data and Semantic Web community should focus on PROV-O defining PROV classes and properties specified in an OWL-RL ontology. For further details, PROV-DM and PROV-CONSTRAINTS specify the constraints applicable to the data model, and its interpretation. PROV-SEM provides a mathematical semantics.
The XML community should focus on PROV-XML defining an XML schema for PROV. Further details can also be found in PROV-DM, PROV-CONSTRAINTS, and PROV-SEM.
Developers seeking to retrieve or publish provenance should focus on PROV-AQ.
Readers seeking to implement other PROV serializations should focus on PROV-DM and PROV-CONSTRAINTS. PROV-O, PROV-N, PROV-XML offer examples of mapping to RDF, text, and XML, respectively.

This document was published by the Provenance Working Group as an Editor's Draft. If you wish to make comments regarding this document, please send them to public-prov-wg@w3.org (subscribe, archives). All feedback is welcome.

Publication as an Editor's Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

1. Introduction
2. General grammar considerations
3. PROV-N Productions per Component
4. Toplevel Bundle
5. Media Type
A. Acknowledgements
B. References
- B.1 Normative references
- B.2 Informative references

1. Introduction

Provenance is a record that describes the people, institutions, entities, and activities, involved in producing, influencing, or delivering a piece of data or a thing in the world. Two companion specifications respectively define PROV-DM, a data model for provenance, allowing provenance descriptions to be expressed [PROV-DM] and a set of constraints that provenance descriptions are expected to satisfy [PROV-CONSTRAINTS].

1.1 Purpose of this Document and target audience

A key goal of PROV is the specification of a machine-processable data model for provenance. However, communicating provenance between humans is also important when teaching, illustrating, formalizing, and discussing provenance-related issues. With these two requirements in mind, this document introduces PROV-N, a syntax notation designed to write instances of the PROV data model according to the following design principles:

Technology independence. PROV-N provides a simple syntax that can be mapped to several technologies.
Human readability. PROV-N follows a functional syntax style that is meant to be easily human-readable so it can be used in illustrative examples, such as those presented in the PROV documents suite;
Formality. PROV-N is defined through a formal grammar amenable to be used with parser generators.

PROV-N has several known uses:

It is the notation used in the examples found in [PROV-DM], as well as in the definition of PROV constraints [PROV-CONSTRAINTS];
It is a source language for the encoding of PROV data model instances into a variety of target languages, including amongst others RDF [PROV-RDF] and XML [PROV-XML];
It provides the basis for a formal semantics of the PROV data model [PROV-SEM], in which an interpretation is given to each element of the PROV-N language.

This document introduces the PROV-N grammar along with examples of its usage.

Its target audience is twofold:

Developers of provenance management applications, as well as implementors of new PROV data model encodings, and thus in particular of PROV-N parsers. These readers may be interested in the entire structure of the grammar, starting from the top level nonterminal bundle.
Readers of the [PROV-DM] and of [PROV-CONSTRAINTS] documents, who are interested in the details of the formal language underpinning the notation used in the examples and in the definition of the constraints. Those readers may find the expression nonterminal a useful entry point into the grammar.

1.2 Structure of this Document

This document structured as follows.

Section 2 provides general consideration about the PROV-N grammar.

Section 3 presents the grammar of all expressions of the language grouped according to the PROV data model components.

Section 4 defines the grammar of toplevel bundles, a house-keeping construct of PROV-N capable of packaging up PROV-N expressions and namespace declarations.

Section 5 defines media type for the PROV-N notation.

1.3 Notational Conventions

The key words "must", "must not", "required", "shall", "shall not", "should", "should not", "recommended", "may", and "optional" in this document are to be interpreted as described in [RFC2119].

The following namespaces prefixes are used throughout this document.

Table 1: Prefix and Namespaces used in this specification
prefix	namespace uri	definition
prov	http://www.w3.org/ns/prov#	The PROV namespace (see Section 4.7.1)
xsd	http://www.w3.org/2000/10/XMLSchema#	XML Schema Namespace [XMLSCHEMA-2]
rdf	http://www.w3.org/1999/02/22-rdf-syntax-ns#	The RDF namespace [RDF-CONCEPTS]
(others)	(various)	All other namespace prefixes are used in examples only. In particular, URIs starting with "http://example.com" represent some application-dependent URI [URI]

2. General grammar considerations

2.1 Functional-style Syntax

PROV-N adopts a functional-style syntax consisting of a predicate name and an ordered list of terms. All PROV data model relations involve two primary elements, the subject and the object, in this order. Furthermore, some expressions also admit additional elements that further characterize it.

Example 1

The following expression should be read as "e2 was derived from e1". Here e2 is the subject, and e1 is the object.

wasDerivedFrom(e2, e1)

Example 2

In the following expressions, the optional activity a along with the generation and usage identifiers g2 and u1:

wasDerivedFrom(e2, e1, a, g2, u1)

2.2 EBNF Grammar

The grammar is specified using the Extended Backus-Naur Form (EBNF) notation.

Each production rule (or production, for short) in the grammar defines one non-terminal symbol E, in the following form:

E ::= term

Within the term on the right-hand side of a rule, the following terms are used to match strings of one or more characters:

E: matches term satisfying rule for symbol E.
abc: matches the literal string inside the single quotes.
term: optional term, matches term or nothing.
term: matches one or more occurrences of term.
term: matches zero or more occurrences of term.
term | term: matches one of the two terms.

The grammar is centered on nonterminals for various types of expression. The main production is introduced here below as it reflects the rationale for the design of the entire grammar. Note that parser developers may use the top level bundle nonterminal as a starting point instead. Each expression non-terminal expression, i.e., entityExpression, activityExpression etc., corresponds to one element (entity, activity, etc.) of the PROV data model.

A PROV-N document consists of a collection of expressions, wrapped in a toplevel bundle with some namespace declarations, such that the text for an element matches the corresponding expression production of the grammar.

2.3 Optional terms in expressions

Some terms in an expression may be optional. For example:

Example 3

wasDerivedFrom(e2, e1, a, g2, u1)
wasDerivedFrom(e2, e1)

In a derivation expression, the activity, generation, and usage are optional terms. They are specified in the first derivation, but not in the second.

Example 4

activity(a2, 2011-11-16T16:00:00, 2011-11-16T16:00:01)
activity(a1)

The start and end times for Activity a1 are optional. They are specified in the first expression, but not in the second.

The general rule for optionals is that, if none of the optionals are used in the expression, then they are simply omitted, resulting in a simpler expression as in the examples above.

However, it may be the case that only some of the optional terms are omitted. Because the position of the terms in the expression matters, an additional marker must be used to indicate that a particular term is not available. The symbol '-' is used for this purpose.

Example 5

In the first expression below, all optionals are specified. However in the second and third, only one optional is specified, forcing the use of the marker for the missing terms.

wasDerivedFrom(e2, e1, a, g2, u1)
wasDerivedFrom(e2, e1, -, -, u1)
wasDerivedFrom(e2, e1, a, -, -)

Note that the more succinct form is just shorthand for a complete expression with all the markers specified:

Example 6

activity(a1)
activity(a1, -, -)

2.4 Identifiers and attributes

Most expressions defined in the grammar include the use of two terms: an identifier and a set of attribute-value pairs, delimited by square brackets. Identifiers are optional except for Entities, Activites, and Agents. Identifiers are always the first term in any expression. By convention, optional identifiers are separated using a semi-colon ';'. This makes it possible to completely omit an optional identifier with no ambiguity arising. Also, if the set of attribute-value pairs is present, it is always the last term in any expression.

Example 7

Derivation has an optional identifier. In the first expression, the identifier is not available, while it is explicit in the second. The third example shows that one can optionally indicate the missing identifier using the - marker.

wasDerivedFrom(e2, e1)
wasDerivedFrom(d; e2, e1)
wasDerivedFrom(-; e2, e1)

Lack of attributes can be equivalently expressed by omitting the list, or by using an empty list.

Example 8

The first and second activities have no attributes. The third activity has two attributes.

activity(ex:a10)
activity(ex:a10, [])
activity(ex:a10, [ex:param1="a", ex:param2="b"])

2.5 Comments

Comments in PROV-N take two forms:

'//' outside an IRI_REF or STRING_LITERAL; such cooments continue to the end of line (marked by characters U+000D or U+000A) or end of file if there is no end of line after the comment marker.
'/*' ... '*/', outside an IRI_REF or STRING_LITERAL.

Comments are treated as white space.

3. PROV-N Productions per Component

This section introduces grammar productions for each expression, followed by small examples of expressions illustrating the grammar. Strings conforming to the grammar are valid expressions in the PROV-N language.

3.1 Component 1: Entities and Activities

3.1.1 Entity

[3]	`entityExpression`	::=	`"entity" "(" identifier optionalAttributeValuePairs ")"`
[4]	`optionalAttributeValuePairs`	::=	`( "," "[" attributeValuePairs "]" )?`
[5]	`attributeValuePairs`	::=	`( \| attributeValuePair ( "," attributeValuePair )* )`
[6]	`attributeValuePair`	::=	`attribute "=" literal`

The following table summarizes how each constituent of a PROV-DM Entity maps to a non-terminal.

Entity	Non-Terminal

id	`identifier`
attributes	`optionalAttributeValuePairs`

Example 9

entity(tr:WD-prov-dm-20111215, [ prov:type="document" ])

Here tr:WD-prov-dm-20111215 is the entity identifier, and [ prov:type="document" ] groups the optional attributes, only one in this example, with their values.


entity(tr:WD-prov-dm-20111215)

Here, the optional attributes are absent.

3.1.2 Activity

[7]	`activityExpression`	::=	`"activity" "(" identifier ( "," timeOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"`
[8]	`timeOrMarker`	::=	`( time \| "-" )`

The following table summarizes how each constituent of a PROV-DM Activity maps to a non-terminal.

Activity	Non-Terminal

id	`identifier`
startTime	`timeOrMarker`
endTime	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 10

activity(ex:a10, 2011-11-16T16:00:00, 2011-11-16T16:00:01, [prov:type="createFile"])

Here ex:a10 is the activity identifier, 2011-11-16T16:00:00 and 2011-11-16T16:00:01 are the optional start and end times for the activity, and [prov:type="createFile"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

activity(ex:a10)
activity(ex:a10, -, -)
activity(ex:a10, -, -, [prov:type="edit"])
activity(ex:a10, -, 2011-11-16T16:00:00)
activity(ex:a10, 2011-11-16T16:00:00, -)
activity(ex:a10, 2011-11-16T16:00:00, -, [prov:type="createFile"])
activity(ex:a10, [prov:type="edit"])

3.1.3 Generation

[9]	`generationExpression`	::=	`"wasGeneratedBy" "(" optionalIdentifier eIdentifier ( "," aIdentifierOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"`
[10]	`optionalIdentifier`	::=	`( identifierOrMarker ";" )?`
[11]	`identifierOrMarker`	::=	`( identifier \| "-" )`

The following table summarizes how each constituent of a PROV-DM Generation maps to a non-terminal.

Generation	Non-Terminal

id	`optionalIdentifier`
entity	`eIdentifier`
activity	`aIdentifierOrMarker`
time	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 11

wasGeneratedBy(ex:g1; tr:WD-prov-dm-20111215, ex:edit1, 2011-11-16T16:00:00,  [ex:fct="save"])

Here ex:g1 is the optional generation identifier, tr:WD-prov-dm-20111215 is the identifier of the entity being generated, ex:edit1 is the optional identifier of the generating activity, 2011-11-16T16:00:00 is the optional generation time, and [ex:fct="save"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasGeneratedBy(e2, a1, tr:WD-prov-dm-20111215)
wasGeneratedBy(e, ex:edit1, 2011-11-16T16:00:00)
wasGeneratedBy(e2, a1, -, [ex:fct="save"])     
wasGeneratedBy(e2, [ex:fct="save"])     
wasGeneratedBy(ex:g1; e)
wasGeneratedBy(ex:g1; e, a, tr:WD-prov-dm-20111215)

Even though the production generationExpression allows for expressions wasGeneratedBy(e2, -, -) and wasGeneratedBy(-; e2, -, -), these expressions are not valid in PROV-N, since at least one of id, activity, time, and attributes must be present.

3.1.4 Usage

[12] usageExpression ::= "used" "(" optionalIdentifier aIdentifier "," ( "," eIdentifierOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Usage maps to a non-terminal.

Usage	Non-Terminal

id	`optionalIdentifier`
activity	`aIdentifier`
entity	`eIdentifierOrMarker`
time	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 12

used(ex:u1; ex:act2, ar3:0111, 2011-11-16T16:00:00, [ex:fct="load"])

Here ex:u1 is the optional usage identifier, ex:act2 is the identifier of the using activity, ar3:0111 is the identifier of the entity being used, 2011-11-16T16:00:00 is the optional usage time, and [ex:fct="load"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

used(ex:act2)
used(ex:act2, ar3:0111, 2011-11-16T16:00:00)
used(a1,e1, -, [ex:fct="load"])
used(ex:u1; ex:act2, ar3:0111, -)

Even though the production usageExpression allows for expressions used(a2, -, -) and used(-; e2, -, -), these expressions are not valid in PROV-N, since at least one of id, entity, time, and attributes must be present.

3.1.5 Communication

[16] communicationExpression ::= "wasInformedBy" "(" optionalIdentifier aIdentifier "," aIdentifier optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Communication maps to a non-terminal.

Communication	Non-Terminal

id	`optionalIdentifier`
informed	`aIdentifier`
informant	`aIdentifier`
attributes	`optionalAttributeValuePairs`

Example 13

wasInformedBy(ex:inf1; ex:a1, ex:a2, [ex:param1="a", ex:param2="b"])

Here ex:inf1 is the optional communication identifier, ex:a1 is the identifier of the informed activity, ex:a2 is the identifier of the informant activity, and [ex:param1="a", ex:param2="b"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasInformedBy(ex:a1, ex:a2)
wasInformedBy(ex:a1, ex:a2, [ex:param1="a", ex:param2="b"])
wasInformedBy(i; ex:a1, ex:a2)
wasInformedBy(i; ex:a1, ex:a2, [ex:param1="a", ex:param2="b"])

3.1.6 Start

[13] startExpression ::= "wasStartedBy" "(" optionalIdentifier aIdentifier ( "," eIdentifierOrMarker "," aIdentifierOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Start maps to a non-terminal.

Start	Non-Terminal

id	`optionalIdentifier`
activity	`aIdentifier`
trigger	`eIdentifierOrMarker`
starter	`aIdentifierOrMarker`
time	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 14

wasStartedBy(s; ex:act2, ex:trigger, ex:act1, 2011-11-16T16:00:00, [ex:param="a"])

Here s is the optional start identifier, ex:act2 is the identifier of the started activity, ex:trigger is the optional identifier for the entity that triggered the activity start, ex:act1 is the optional identifier for the activity that generated the (possibly unspecified) entity ex:trigger, 2011-11-16T16:00:00 is the optional start time, and [ex:param="a"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasStartedBy(ex:act2, -, ex:act1, -)
wasStartedBy(ex:act2, -, ex:act1, 2011-11-16T16:00:00)
wasStartedBy(ex:act2, -, -, 2011-11-16T16:00:00)
wasStartedBy(ex:act2, [ex:param="a"])
wasStartedBy(s; ex:act2, e, ex:act1, 2011-11-16T16:00:00)

Note: Even though the production startExpression allows for expressions wasStartedBy(e2, -, -) and wasStartedBy(-; e2, -, -), these expressions are not valid in PROV-N, since at least one of id, trigger, starter, time, and attributes must be present.

3.1.7 End

[14] endExpression ::= "wasEndedBy" "(" optionalIdentifier aIdentifier ( "," eIdentifierOrMarker "," aIdentifierOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM End maps to a non-terminal.

End	Non-Terminal

id	`optionalIdentifier`
activity	`aIdentifier`
trigger	`eIdentifierOrMarker`
ender	`aIdentifierOrMarker`
time	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 15

wasEndedBy(s; ex:act2, ex:trigger,ex:act3,  2011-11-16T16:00:00, [ex:param="a"])

Here s is the optional start identifier, ex:act2 is the identifier of the ending activity, ex:trigger is the identifier of the entity that triggered the activity end, ex:act3 is the optional identifier for the activity that generated the (possibly unspecified) entity e, 2011-11-16T16:00:00 is the optional usage time, and [ex:param="a"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasEndedBy(ex:act2, ex:trigger, -, -)
wasEndedBy(ex:act2, ex:trigger, -, 2011-11-16T16:00:00)
wasEndedBy(ex:act2, -, -, 2011-11-16T16:00:00)
wasEndedBy(ex:act2, -, -, 2011-11-16T16:00:00, [ex:param="a"])
wasEndedBy(e; ex:act2)
wasEndedBy(e; ex:act2, ex:trigger, -, 2011-11-16T16:00:00)

Note:Even though the production endExpression allows for expressions wasEndedBy(e2, -, -) and wasEndedBy(-; e2, -, -), these expressions are not valid in PROV-N, since at least one of id, trigger, ender, time, and attributes must be present.

3.1.8 Invalidation

[15] invalidationExpression ::= "wasInvalidatedBy" "(" optionalIdentifier eIdentifier ( "," aIdentifierOrMarker "," timeOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Invalidation maps to a non-terminal.

Invalidation	Non-Terminal

id	`optionalIdentifier`
entity	`eIdentifier`
activity	`aIdentifierOrMarker`
time	`timeOrMarker`
attributes	`optionalAttributeValuePairs`

Example 16

wasInvalidatedBy(ex:i1; tr:WD-prov-dm-20111215, ex:edit1, 2011-11-16T16:00:00,  [ex:fct="save"])

Here ex:i1 is the optional invalidation identifier, tr:WD-prov-dm-20111215 is the identifier of the entity being invalidated, ex:edit1 is the optional identifier of the invalidating activity, 2011-11-16T16:00:00 is the optional invalidation time, and [ex:fct="save"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasInvalidatedBy(tr:WD-prov-dm-20111215, ex:edit1, -)
wasInvalidatedBy(tr:WD-prov-dm-20111215, ex:edit1, 2011-11-16T16:00:00)
wasInvalidatedBy(e2, a1, -, [ex:fct="save"])     
wasInvalidatedBy(e2, -, -, [ex:fct="save"])     
wasInvalidatedBy(ex:i1; tr:WD-prov-dm-20111215, ex:edit1, -)
wasInvalidatedBy(tr:WD-prov-dm-20111215, ex:edit1, -)

Even though the production invalidationExpression allows for expressions wasInvalidatedBy(e2, -, -) and wasInvalidatedBy(-; e2, -, -), these expressions are not valid in PROV-N, since since at least one of id, activity, time, and attributes must be present.

3.2 Component 2: Derivations

3.2.1 Derivation

[21] derivationExpression ::= "wasDerivedFrom" "(" optionalIdentifier eIdentifier "," eIdentifier ( "," aIdentifierOrMarker "," gIdentifierOrMarker "," uIdentifierOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Derivation maps to a non-terminal.

Derivation	Non-Terminal

id	`optionalIdentifier`
generatedEntity	`eIdentifier`
usedEntity	`eIdentifier`
activity	`aIdentifierOrMarker`
generation	`gIdentifierOrMarker`
usage	`uIdentifierOrMarker`
attributes	`optionalAttributeValuePairs`

Example 17

wasDerivedFrom(d, e2, e1, a, g2, u1, [ex:comment="a righteous derivation"])

Here d is the optional derivation identifier, e2 is the identifier for the entity being derived, e1 is the identifier of the entity from which e2 is derived, a is the optional identifier of the activity which used/generated the entities, g2 is the optional identifier of the generation, u1 is the optional identifier of the usage, and [ex:comment="a righteous derivation"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasDerivedFrom(e2, e1)
wasDerivedFrom(e2, e1, a, g2, u1)
wasDerivedFrom(e2, e1, -, g2, u1)
wasDerivedFrom(e2, e1, a, -, u1)
wasDerivedFrom(e2, e1, a, g2, -)
wasDerivedFrom(e2, e1, a, -, -)
wasDerivedFrom(e2, e1, -, -, u1)
wasDerivedFrom(e2, e1, -, -, -)
wasDerivedFrom(d, e2, e1, a, g2, u1)
wasDerivedFrom(-, e2, e1, a, g2, u1)

3.2.2 Revision

Example 18

wasDerivedFrom(d, e2, e1, a, g2, u1, [prov:type="prov:WasRevisionOf", ex:comment="a righteous derivation"])

Here, the derivation from Example 17 is extended with a prov:type attribute and value prov:WasRevisionOf.

3.2.3 Quotation

Example 19

wasDerivedFrom(quoteId1; ex:blockQuote,ex:blog, ex:act1, ex:g, ex:u, [ prov:type='prov:WasQuotedFrom' ])

Here, the derivation is provided with a prov:type attribute and value prov:WasQuotedFrom.

3.2.4 Original Source

Example 20

wasDerivedFrom(src1;  ex:e1, ex:e2, ex:act, ex:g, ex:u, [ prove:type='prov:HadOriginalSource' ])

Here, the derivation is provided with a prov:type attribute and value prov:HadOriginalSource.

3.3 Component 3: Agents and Responsibility

3.3.1 Agent

[17] agentExpression ::= "agent" "(" identifier optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Agent maps to a non-terminal.

Agent	Non-Terminal

id	`identifier`
attributes	`optionalAttributeValuePairs`

Example 21

agent(ag4, [ prov:type="prov:Person", ex:name="David" ])

Here ag is the agent identifier, and [ prov:type="prov:Person", ex:name="David" ] are optional attributes.

In the next example, the optional attributes are omitted.

agent(ag4)

3.3.2 Attribution

[18] attributionExpression ::= "wasAttributedTo" "(" optionalIdentifier eIdentifier "," agIdentifier optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Attribution maps to a non-terminal.

Attribution	Non-Terminal

id	`optionalIdentifier`
entity	`eIdentifier`
agent	`agIdentifier`
attributes	`optionalAttributeValuePairs`

Example 22

wasAttributedTo(id; e, ag, [ex:license='cc:attributionURL' ])

Here id is the optional attribution identifier, e is an entity identifier, ag is the identifier of the agent to whom the entity is abscribed, and [ex:license='cc:attributionURL' ] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasAttributedTo(e, ag)
wasAttributedTo(e, ag, [ex:license='cc:attributionURL' ])

3.3.3 Association

[19] associationExpression ::= "wasAssociatedWith" "(" optionalIdentifier aIdentifier "," agIdentifierOrMarker ( "," eIdentifierOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Association maps to a non-terminal.

Association	Non-Terminal

id	`optionalIdentifier`
activity	`aIdentifier`
agent	`agIdentifierOrMarker`
plan	`eIdentifierOrMarker`
attributes	`optionalAttributeValuePairs`

Example 23

wasAssociatedWith(ex:agas; ex:a1, ex:ag1, ex:e1, [ex:param1="a", ex:param2="b"])

Here ex:agas is the optional attribution identifier, ex:a1 is an activity identifier, ex:ag1 is the optional identifier of the agent associated to the activity, ex:e1 is the optional identifier of the plan used by the agent in the context of the activity, and [ex:param1="a", ex:param2="b"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

wasAssociatedWith(ex:a1, -, ex:e1)
wasAssociatedWith(ex:a1, ex:ag1)
wasAssociatedWith(ex:a1, ex:ag1, ex:e1)
wasAssociatedWith(ex:a1, ex:ag1, ex:e1, [ex:param1="a", ex:param2="b"])
wasAssociatedWith(a; ex:a1, -, ex:e1)

Note:The production associationExpression allows for expressions wasAssociatedWith(a, -, -) and wasAssociatiedWith(-; a, -, -). However, these expressions are not valid in PROV-N, since at least one of id, agent, plan, and attributes must be present.

3.3.4 Delegation

[20] delegationExpression ::= "actedOnBehalfOf" "(" optionalIdentifier agIdentifier "," agIdentifier ( "," aIdentifierOrMarker )? optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Delegation maps to a non-terminal.

Delegation	Non-Terminal

id	`optionalIdentifier`
delegate	`agIdentifier`
responsible	`agIdentifier`
activity	`aIdentifierOrMarker`
attributes	`optionalAttributeValuePairs`

Example 24

actedOnBehalfOf(del1; ag2, ag1, a, [prov:type="contract"])

Here del1 is the optional delegation identifier, ag2 is the identifier for the delegate agent, ag1 is the identifier of the responsible agent, a is the optional identifier of the activity for which the delegation link holds, and [prov:type="contract"] are optional attributes.

The remaining examples show cases where some of the optionals are omitted.

actedOnBehalfOf(ag1, ag2)
actedOnBehalfOf(ag1, ag2, a)
actedOnBehalfOf(ag1, ag2, -, [prov:type="delegation"])
actedOnBehalfOf(ag2, ag3, a, [prov:type="contract"])
actedOnBehalfOf(r; ag2, ag3, a, [prov:type="contract"])

3.3.5 Trace

[22] tracedToExpression ::= "tracedTo" "(" optionalIdentifier eIdentifier "," eIdentifier optionalAttributeValuePairs ")"

The following table summarizes how each constituent of a PROV-DM Trace maps to a non-terminal.

Trace	Non-Terminal

id	`optionalIdentifier`
entity	`eIdentifier`
ancestor	`eIdentifier`
attributes	`optionalAttributeValuePairs`

Example 25

tracedTo(id,e2,e1,[ex:param="a"])

Here id is the optional trace identifier, e2 is an entity identifier, e1 is the identifier for an ancestor entity that e2 depends on, and [ex:param="a"] is the optional set of attributes.

The remaining examples show cases where some of the optionals are omitted.

tracedTo(e2,e1)
tracedTo(e2,e1,[ex:param="a"])
tracedTo(id; e2,e1)

3.4 Component 4: Bundles

3.4.1 Bundle Declaration

[33] namedBundle ::= "bundle" identifier (namespaceDeclarations)? (expression)* "endBundle"

Example 26

bundle ex:author-view
  agent(ex:Paolo,   [ prov:type='prov:Person' ])
  agent(ex:Simon,   [ prov:type='prov:Person' ])
  ...
endBundle

Here ex:author-view is the name of the bundle.

3.5 Component 5: Alternate Entities

3.5.1 Alternate

[23] alternateExpression ::= "alternateOf" "(" eIdentifier "," eIdentifier ")"

The following table summarizes how each constituent of a PROV-DM Alternate maps to a non-terminal.

Alternate	Non-Terminal

alternate1	`eIdentifier`
alternate2	`eIdentifier`

Example 27

alternateOf(tr:WD-prov-dm-20111215,ex:alternate-20111215)

Here tr:WD-prov-dm-20111215 is alternate for ex:alternate-20111215.

3.5.2 Specialization

[24] specializationExpression ::= "specializationOf" "(" eIdentifier "," eIdentifier ")"

The following table summarizes how each constituent of a PROV-DM Specialization maps to a non-terminal.

Specialization	Non-Terminal

specificEntity	`eIdentifier`
generalEntity	`eIdentifier`

Example 28

specializationOf(tr:WD-prov-dm-20111215,tr:prov-dm)

Here tr:WD-prov-dm-20111215 is a specialization of tr:prov-dm.

3.5.3 Contextualization

[25] contextualizationExpression ::= "contextualizationOf" "(" identifier "," identifier "," bIdentifier ")"

The following table summarizes how each constituent of a PROV-DM Contextualization maps to a non-terminal.

Contextualization	Non-Terminal

local	`eIdentifier`
contextualized	`eIdentifier`
context	`bIdentifier`

Example 29

  contextualization(ex:report1_as_in_b1, ex:report1, ex:b1)

Here ex:report1_as_in_b1 is an entity identifier, ex:report1 is an entity identifier, ex:b1 is the identifier for a bundle

3.6 Component 6: Collections

3.6.1 Insertion

[26]	`insertionExpression`	::=	`"derivedByInsertionFrom" "(" optionalIdentifier dIdentifier "," dIdentifier "," keyEntitySet optionalAttributeValuePairs ")"`
[27]	`keyEntitySet`	::=	`"{" "(" literal "," identifier ")" ( "," "(" literal "," identifier ")" )* "}"`

The following table summarizes how each constituent of a PROV-DM Insertion maps to a non-terminal.

Insertion	Non-Terminal

id	`optionalIdentifier`
after	`cIdentifier`
before	`cIdentifier`
key-entity-set	`keyEntitySet`
attributes	`optionalAttributeValuePairs`

Example 30

 derivedByInsertionFrom(id; c1, c, {("k1", v1), ("k2", v2)}, [])

Here id is the optional insertion identifier, c1 is the identifier for the collection after the insertion, c is the identifier for the collection before the insertion, {("k1", v1), ("k2", v2)} is the set of key-value pairs that have been inserted in c, and [] is the optional (empty) set of attributes.

The remaining examples show cases where some of the optionals are omitted.

 derivedByInsertionFrom(c1, c, {("k1", v1), ("k2", v2)})  
 derivedByInsertionFrom(c1, c, {("k1", v1)})  
 derivedByInsertionFrom(c1, c, {("k1", v1), ("k2", v2)}, [])

3.6.2 Removal

[29]	`removalExpression`	::=	`"derivedByRemovalFrom" "(" optionalIdentifier dIdentifier "," dIdentifier "," keySet optionalAttributeValuePairs ")"`
[30]	`keySet`	::=	`"{" literal ( "," literal )* "}"`

The following table summarizes how each constituent of a PROV-DM Removal maps to a non-terminal.

Removal	Non-Terminal

id	`optionalIdentifier`
after	`cIdentifier`
before	`cIdentifier`
key-set	`keySet`
attributes	`optionalAttributeValuePairs`

Example 31

 derivedByRemovalFrom(id; c3, c, {"k1", "k3"}, [])

Here id is the optional removal identifier, c1 is the identifier for the collection after the removal, c is the identifier for the collection before the removal, {("k1", v1), ("k2", v2)} is the set of key-value pairs that have been removed from c, and [] is the optional (empty) set of attributes.

The remaining examples show cases where some of the optionals are omitted.

   derivedByRemovalFrom(c3, c1, {"k1", "k3"})               
   derivedByRemovalFrom(c3, c1, {"k1"})               
   derivedByRemovalFrom(c3, c1, {"k1", "k3"}, [])

3.6.3 Membership

[31]	`membershipExpression`	::=	`"memberOf" "(" optionalIdentifier dIdentifier "," keyEntitySet complete optionalAttributeValuePairs ")" \| "memberOf" "(" optionalIdentifier cIdentifier "," entitySet complete optionalAttributeValuePairs ")"`
[32]	`complete`	::=	`( "," ( "true" \| "false" \| "-" ) )?`
[28]	`entitySet`	::=	`"{" (eIdentifier)* "}"`

The following table summarizes how each constituent of a PROV-DM Membership maps to a non-terminal.

Collection Membership	Non-Terminal

id	`optionalIdentifier`
collection	`cIdentifier`
entity-set	`entitySet`
complete	`complete`
attributes	`optionalAttributeValuePairs`

Dictionary Membership	Non-Terminal

id	`optionalIdentifier`
dictionary	`dIdentifier`
key-entity-set	`keyEntitySet`
complete	`complete`
attributes	`optionalAttributeValuePairs`

Example 32

   memberOf(mId, c, {e1, e2, e3}, [])   // Collection membership
   memberOf(mId, c, {("k4", v4), ("k5", v5)}, [])   // Dictionary membership

Here mid is the optional membership identifier, c is the identifier for the collection whose membership is stated, {("k4", v4), ("k5", v5)} is the set of key-value pairs that are members of c, and [] is the optional (empty) set of attributes.

The remaining examples show cases for Dictionaries, where some of the optionals are omitted. Key-entity sets are replaced with Entity sets for the corresponding generic Collections examples.

memberOf(c3, {("k4", v4), ("k5", v5)})
memberOf(c3, {("k4", v4)})
memberOf(c3, {("k4", v4)}, false)
memberOf(c3, {("k4", v4)}, true)
memberOf(c3, {("k4", v4), ("k5", v5)},[])  
memberOf(c3, {("k4", v4), ("k5", v5)},true, [])

3.7 Further Expressions

This section defines further expressions of PROV-N.

3.7.1 Namespace Declaration

[54]	`namespaceDeclarations`	::=	`( defaultNamespaceDeclaration \| namespaceDeclaration ) (namespaceDeclaration)*`
[55]	`namespaceDeclaration`	::=	`"prefix" QUALIFIED_NAME namespace`
[57]	`namespace`	::=	`IRI_REF`
[56]	`defaultNamespaceDeclaration`	::=	`"default" IRI_REF`

In PROV-N, the following prefixes are reserved:

prov denotes the PROV namespace with URI http://www.w3.org/ns/prov#
xsd denotes the XML Schema namespace with URI http://www.w3.org/2001/XMLSchema#.

A PROV-N document must not redeclare prefixes prov and xsd.

Example 33

The following example declares three namespaces, one default, and two with explicit prefixes ex1 and ex2.

bundle
  default <http://example.org/0/>
  prefix ex1 <http://example.org/1/>
  prefix ex2 <http://example.org/2/>
...
endBundle

3.7.2 Identifier

A qualified name is a name subject to namespace interpretation. It consists of a namespace, denoted by an optional prefix, and a local name. The PROV data model stipulates that a qualified name can be mapped into an IRI by concatenating the IRI associated with the prefix and the local part.

A qualified name's prefix is optional. If a prefix occurs in a qualified name, it refers to a namespace declared in a namespace declaration. In the absence of prefix, the qualified name refers to the default namespace.

A PROV qualified name QUALIFIED_NAME has a more permissive syntax then XML's QName [XML-NAMES] and SPARQL PrefixedName [RDF-SPARQL-QUERY]. It is a PROV requirement that the concatenation of the namespace with the local part results in a valid IRI [IRI]. Given that ',' (comma), ';' (semi-colon), '=' (equal), '(' (left bracket), ')' (right bracket), '[' (left square bracket), ']' (right square bracket) are used by the PROV notation as delimiters, they are not allowed in local parts. Instead, they can be %-escaped or incorporated in the IRI denoted by a prefix.

Qualified names QUALIFIED_NAME consist of a prefix and a local part. Prefixes follow the production PN_PREFIX defined by SPARQL [RDF-SPARQL-QUERY]. Local parts have to be conformant with PN_LOCAL, which extends the original SPARQL PN_LOCAL definition by allowing further characters and %-escaped charaters (see PN_CHARS_OTHERS).

[34]	`eIdentifier`	::=	`identifier`
[35]	`aIdentifier`	::=	`identifier`
[36]	`agIdentifier`	::=	`identifier`
[37]	`gIdentifier`	::=	`identifier`
[38]	`uIdentifier`	::=	`identifier`
[40]	`cIdentifier`	::=	`identifier`
[39]	`dIdentifier`	::=	`identifier`
[41]	`bIdentifier`	::=	`identifier`
[42]	`eIdentifierOrMarker`	::=	`( eIdentifier \| "-" )`
[43]	`aIdentifierOrMarker`	::=	`( aIdentifier \| "-" )`
[44]	`agIdentifierOrMarker`	::=	`( agIdentifier \| "-" )`
[45]	`gIdentifierOrMarker`	::=	`( gIdentifier \| "-" )`
[46]	`uIdentifierOrMarker`	::=	`( uIdentifier \| "-" )`
[47]	`identifier`	::=	`QUALIFIED_NAME`
[58]	<`QUALIFIED_NAME`>	::=	`( PN_PREFIX ":" )? PN_LOCAL \| PN_PREFIX ":"`
[77]	<`PN_LOCAL`>	::=	`( PN_CHARS_U \| [0-9] \| PN_CHARS_OTHERS ) ( ( PN_CHARS \| "." \| PN_CHARS_OTHERS )* ( PN_CHARS \| PN_CHARS_OTHERS ) )?`
[78]	<`PN_CHARS_OTHERS`>	::=	`PERCENT \| "/" \| "@" \| "~" \| "&" \| "+" \| "?" \| "#" \| "$"`
[79]	<`PERCENT`>	::=	`"%" HEX HEX`
[80]	<`HEX`>	::=	`[0-9] \| [A-F] \| [a-f]`

Example 34

Examples of articles on the BBC Web site seen as entities.

bundle
  prefix bbc <http://www.bbc.co.uk/>
  prefix bbcNews <http://www.bbc.co.uk/news/>

  entity(bbc:)                          // bbc site itself
  entity(bbc:news/)                     // bbc news
  entity(bbc:news/world-asia-17507976)  // a given news article

  entity(bbcNews:)                      // an alternative way of referring to the bbc news site

endBundle

Example 35

Examples of entities with declared and default namespace.

bundle
  default <http://example.org/2/>
  prefix ex <http://example.org/1/>

  entity(ex:a)     //  corresponds to IRI http://example.org/1/a
  entity(ex:a/)    //  corresponds to IRI http://example.org/1/a/
  entity(ex:a/b)   //  corresponds to IRI http://example.org/1/a/b
  entity(b)        //  corresponds to IRI http://example.org/2/b
  entity(ex:1234)  //  corresponds to IRI http://example.org/2/1234
  entity(4567)     //  corresponds to IRI http://example.org/2/4567
endBundle

Note:The productions for qualifiedName and prefix are conflicting. In the context of a namespaceDeclaration, a parser should give precedence to the production for prefix.

3.7.3 Attribute

[48] attribute ::= QUALIFIED_NAME

The reserved attributes in the PROV namespace are the following.

prov:label
prov:location
prov:role
prov:type
prov:value

3.7.4 Literal

[50]	`literal`	::=	`typedLiteral \| convenienceNotation`
[51]	`typedLiteral`	::=	`STRING_LITERAL "%%" datatype`
[52]	`datatype`	::=	`QUALIFIED_NAME`

[53]	`convenienceNotation`	::=	`STRING_LITERAL \| INT_LITERAL \| QUALIFIED_NAME_LITERAL`
[64]	<`STRING_LITERAL`>	::=	`STRING_LITERAL2`
[66]	<`INT_LITERAL`>	::=	`("-")? (DIGIT)+`
[67]	<`QUALIFIED_NAME_LITERAL`>	::=	`"'" QUALIFIED_NAME "'"`

In production prod-datatype, the QUALIFIED_NAME is used to denote a PROV data type [PROV-DM].

The non terminals STRING_LITERAL, INT_LITERAL, and QUALIFIED_NAME_LITERAL are syntactic sugar for quoted strings with datatype xsd:string, xsd:int, and prov:QUALIFIED_NAME respectively.

In particular, a Literal may be an IRI-typed string (with datatype xsd:anyURI); such IRI has no specific interpretation in the context of PROV.

Note:The productions for prov:QUALIFIED_NAME and INT_LITERAL are conflicting. In the context of a literal, a parser should give precedence to the production for INT_LITERAL.

3.7.4.1 Reserved Type Values

The reserved type values in the PROV namespace are the following.

prov:Bundle
prov:Collection
prov:Dictionary
prov:EmptyDictionary
prov:HadOriginalSource
prov:Organization
prov:Person
prov:Plan
prov:SoftwareAgent
prov:WasQuotedFrom
prov:WasRevisionOf

Example 36

The agent ag is a person (type: prov:Person), whereas the entity pl is a plan (type: prov:Plan).

agent(ag,  [ prov:type='prov:Person' ])
entity(pl, [ prov:type='prov:Plan' ])

3.7.4.2 Time Values

Time instants are defined according to xsd:dateTime [XMLSCHEMA-2].

[49]	`time`	::=	`ISODATETIME`
[60]	<`DIGIT`>	::=	`[0-9]`
[61]	<`ISODATETIME`>	::=	`DIGIT DIGIT DIGIT DIGIT "-" DIGIT DIGIT "-" DIGIT DIGIT "T" DIGIT DIGIT ":" DIGIT DIGIT ":" DIGIT DIGIT ( "." DIGIT ( DIGIT (DIGIT)? )? )? ( "Z" \| TIMEZONEOFFSET )?`
[62]	<`TIMEZONEOFFSET`>	::=	`( "+" \| "-" ) DIGIT DIGIT ":" DIGIT DIGIT`

Example 37

The third argument in the following usage expression is a time instance, namely 4pm on 2011-11-16.

used(ex:act2, ar3:0111, 2011-11-16T16:00:00)

4. Toplevel Bundle

A toplevel bundle is a house-keeping construct of PROV-N capable of packaging up PROV-N expressions and namespace declarations. A toplevel bundle forms a self-contained package of provenance descriptions for the purpose of exchanging them. A toplevel bundle may be used to package up PROV-N expressions in response to a request for the provenance of something ([PROV-AQ]).

Given its status of house keeping construct for the purpose of exchanging provenance expressions, a toplevel bundle is not defined as a PROV-N expression (production expression).

A toplevel bundle, written bundle decls exprs bundles endBundle in PROV-N, contains:

namespaceDeclarations: a set decls of namespace declarations, declaring namespaces and associated prefixes, which can be used in attributes and identifiers occurring inside exprs;
expressions: a non-empty set of expressions exprs;
namedBundles: a set of bundle declarations bundles;

A toplevel bundle's text matches the bundle production.

[1] bundle ::= "bundle" (namespaceDeclarations)? (expression)* (namedBundle)* "endBundle"

Example 38

The following container contains expressions related to the provenance of entity e2.

bundle
  default <http://anotherexample.org/>
  prefix ex <http://example.org/>

  entity(e2, [ prov:type="File", ex:path="/shared/crime.txt", ex:creator="Alice", 
               ex:content="There was a lot of crime in London last month."])
  activity(a1, 2011-11-16T16:05:00, -,[prov:type="edit"])
  wasGeneratedBy(e2, a1, -, [ex:fct="save"])     
  wasAssociatedWith(a1, ag2, -, [prov:role="author"])
  agent(ag2, [ prov:type='prov:Person' , ex:name="Bob" ])

endBundle

This container could for instance be returned as the result of a query to a provenance store for the provenance of entity e2 [PROV-AQ].

5. Media Type

The media type of PROV-N is text/prov-n. The content encoding of PROV-N content is UTF-8.

See http://www.w3.org/2002/06/registering-mediatype for Register an Internet Media Type for a W3C Spec.

A. Acknowledgements

WG membership to be listed here.

B. References

B.1 Normative references

[IRI]: M. Duerst, M. Suignard. Internationalized Resource Identifiers (IRI). January 2005. Internet RFC 3987. URL: http://www.ietf.org/rfc/rfc3987.txt
[RDF-CONCEPTS]: Graham Klyne; Jeremy J. Carroll. Resource Description Framework (RDF): Concepts and Abstract Syntax. 10 February 2004. W3C Recommendation. URL: http://www.w3.org/TR/2004/REC-rdf-concepts-20040210
[RDF-SPARQL-QUERY]: Andy Seaborne; Eric Prud'hommeaux. SPARQL Query Language for RDF. 15 January 2008. W3C Recommendation. URL: http://www.w3.org/TR/2008/REC-rdf-sparql-query-20080115
[RFC2119]: S. Bradner. Key words for use in RFCs to Indicate Requirement Levels. March 1997. Internet RFC 2119. URL: http://www.ietf.org/rfc/rfc2119.txt
[URI]: T. Berners-Lee; R. Fielding; L. Masinter. Uniform Resource Identifiers (URI): generic syntax. January 2005. Internet RFC 3986. URL: http://www.ietf.org/rfc/rfc3986.txt
[XML-NAMES]: Richard Tobin; et al. Namespaces in XML 1.0 (Third Edition). 8 December 2009. W3C Recommendation. URL: http://www.w3.org/TR/2009/REC-xml-names-20091208/
[XMLSCHEMA-2]: Paul V. Biron; Ashok Malhotra. XML Schema Part 2: Datatypes Second Edition. 28 October 2004. W3C Recommendation. URL: http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/

B.2 Informative references

[PROV-AQ]: Graham Klyne and Paul Groth (eds.) Luc Moreau, Olaf Hartig, Yogesh Simmhan, James Meyers, Timothy Lebo, Khalid Belhajjame, and Simon Miles Provenance Access and Query. 2011, Working Draft. URL: http://www.w3.org/TR/prov-aq/
[PROV-CONSTRAINTS]: James Cheney, Paolo Missier, and Luc Moreau (eds.)Constraints of the Prov Data Model. 2012, Working Draft. URL: http://www.w3.org/TR/prov-constraints/
[PROV-DM]: Luc Moreau and Paolo Missier (eds.) Khalid Belhajjame, Reza B'Far, Stephen Cresswell, Yolanda Gil, Paul Groth, Graham Klyne, Jim McCusker, Simon Miles, James Myers, Satya Sahoo, and Curt TilmesPROV-DM: The PROV Data Model. 2012, Working Draft. URL: http://www.w3.org/TR/prov-dm/
[PROV-RDF]: James CheneyPROV-RDF Mapping 2012, Working in Progress. URL: http://www.w3.org/2011/prov/wiki/ProvRDF
[PROV-SEM]: James Cheney Formal Semantics Strawman. 2011, Work in progress. URL: http://www.w3.org/2011/prov/wiki/FormalSemanticsStrawman
[PROV-XML]: James CheneyPROV-XML Mapping 2012, Working in Progress. URL: http://www.w3.org/2011/prov/wiki/ProvXML

PROV-N: The Provenance Notation

Internal Release Version (Diffs since last release)

W3C Editor's Draft 14 June 2012

Abstract

Status of This Document

Intended to be Last Call (TBC)

Please Comment By (date TBD)

PROV Family of Specifications

How to read the PROV Family of Specifications

Table of Contents

1. Introduction

1.1 Purpose of this Document and target audience

1.2 Structure of this Document

1.3 Notational Conventions

2. General grammar considerations

2.1 Functional-style Syntax

2.2 EBNF Grammar

2.3 Optional terms in expressions

2.4 Identifiers and attributes

2.5 Comments

3. PROV-N Productions per Component

3.1 Component 1: Entities and Activities

3.1.1 Entity

3.1.2 Activity

3.1.3 Generation

3.1.4 Usage

3.1.5 Communication

3.1.6 Start

3.1.7 End

3.1.8 Invalidation

3.2 Component 2: Derivations

3.2.1 Derivation

3.2.2 Revision

3.2.3 Quotation

3.2.4 Original Source

3.3 Component 3: Agents and Responsibility

3.3.1 Agent

3.3.2 Attribution

3.3.3 Association

3.3.4 Delegation

3.3.5 Trace

3.4 Component 4: Bundles

3.4.1 Bundle Declaration

3.5 Component 5: Alternate Entities

3.5.1 Alternate

3.5.2 Specialization

3.5.3 Contextualization

3.6 Component 6: Collections

3.6.1 Insertion

3.6.2 Removal

3.6.3 Membership

3.7 Further Expressions

3.7.1 Namespace Declaration

3.7.2 Identifier

3.7.3 Attribute

3.7.4 Literal

3.7.4.1 Reserved Type Values

3.7.4.2 Time Values

4. Toplevel Bundle

5. Media Type

A. Acknowledgements

B. References

B.1 Normative references

B.2 Informative references