--- a/model/prov-dm.html Sun Apr 22 13:04:46 2012 -0400
+++ b/model/prov-dm.html Mon Apr 23 08:52:19 2012 +0200
@@ -323,7 +323,7 @@
<li> component 2: agents bearing responsibility for entities that were generated and activities that happened;
<li> component 3: derivations of entities from others;
<li> component 4: properties to link entities that refer to a same thing;
-<li> component 5: collections of entities, whose provenance can itself be tracked;
+<li> component 5: collections forming a logical structure for its members;
<li> component 6: a simple annotation mechanism.
</ul>
@@ -601,7 +601,7 @@
<p>There are two further types of entities, collections and accounts, which are now introduced. </p>
<p>
-<span class="glossary-ref" data-ref="glossary-collection" data-withspan="true"></span> This concept allows for the provenance of the collection itself to be expressed in addition to that of the members. Such a notion of collection corresponds to a wide variety of concrete data structures, such as a <em>maps</em>, <em>dictionaries</em>, or <em>associative arrays</em>, all of which involve a membership relationship between the constituents and the collection. </p>
+<span class="glossary-ref" data-ref="glossary-collection" data-withspan="true"></span> This concept allows for the provenance of the collection itself to be expressed in addition to that of the members. Many different types of collections exist, such as a <em>set</em>, <em>dictionaries</em>, or <em>lists</em>, all of which involve a membership relationship between the constituents and the collection. </p>
<div class="conceptexample" id="collection-example">
<p>
@@ -1016,6 +1016,7 @@
<tr class="component4-color"><td><a>Alternate</a></td><td><a title="alternateOf">alternateOf(alt1, alt2)</a></td></tr>
<tr class="component4-color"><td><a>Specialization</a></td><td><a title="specializationOf">specializationOf(sub, super)</a></td></tr>
<tr class="component5-color"><td><a>Collection</a></td><td><a>Collection</a></td></tr>
+<tr class="component5-color"><td><a>Dictionary</a></td><td><a>Dictionary</a></td></tr>
<tr class="component5-color"><td><a>Insertion</a></td><td><a title="derivedByInsertionFrom">derivedByInsertionFrom(id, c2, c1, {(key_1, e_1), ..., (key_n, e_n)}, attrs)</a></td></tr>
<tr class="component5-color"><td><a>Removal</a></td><td><a title="derivedByRemovalFrom">derivedByRemovalFrom(id, c2, c1, {key_1, ... key_n}, attrs)</a></td></tr>
<tr class="component5-color"><td><a>Membership</a></td><td><a title="memberOf">memberOf(c, {(key_1, e_1), ..., (key_n, e_n)})</a></td></tr>
@@ -2025,7 +2026,7 @@
<h3>Component 5: Collections</h3>
<p>The fifth component of PROV-DM is concerned with the notion of collections.
-A collection is an entity that has some members. The members are themselves entities, and therefore their provenance can be expressed. Some applications need to be able to express the provenance of the collection itself: e.g. who maintains the collection, which members it contains as it evolves, and how it was assembled. The purpose of Component 5 is to define the types and relations that are useful to express the provenance of collections. </p>
+A collection is an entity that has some members. The members are themselves entities, and therefore their provenance can be expressed. Some applications need to be able to express the provenance of the collection itself: e.g. who maintains the collection, which members it contains as it evolves, and how it was assembled. The purpose of Component 5 is to define the types and relations that are useful to express the provenance of collections. In PROV, the concept of Collection is implemented by means of dictionaries. </p>
<p>Figure <a href="#figure-component5">figure-component5</a> depicts
the fifth component with two classes and three associations.
@@ -2034,34 +2035,46 @@
<div style="text-align: center;">
<figure>
-<img src="images/Collections.png" alt="collections"/>
+<img src="images/Dictionaries.png" alt="dictionaries"/>
<figcaption id="figure-component5">Figure 9: Collections Component Overview</figcaption>
</figure>
</div>
-<p>The intent of these relations and types is to express the <em>history of changes that occurred to a collection</em>.
-Changes to collections are about the insertion of entities to collections and the removal of members from collections.
-Indirectly, such history provides a way to reconstruct the contents of a collection.</p>
+<p>The intent of these relations and types is to express the <em>history of changes that occurred to a dictionary</em>.
+Changes to dictionaries are about the insertion of entities in dictionaries and the removal of members from dictionaries.
+Indirectly, such history provides a way to reconstruct the contents of a dictionary.</p>
<section id="term-collection">
<h3>Collection</h3>
<span class="glossary-ref" data-ref="glossary-collection"></span>
-
-<p>Conceptually, a collection has a logical structure consisting of key-entity pairs. This structure is often referred to as a <em>map</em>, and is a generic indexing mechanism that can abstract commonly used data structures, including associative lists (also known as "dictionaries" in some programming languages), relational tables, ordered lists, and more. The specification of such specialized structures in terms of key-value pairs is out of the scope of this document.</p>
-
-<p>A given collection forms a given structure for its members. A different structure (obtained either by insertion or removal of members) constitutes a different collection. Hence,
- for the purpose of provenance, a collection entity is viewed as a snapshot of a structure. Insertion and removal operations result in new snapshots, each snapshot forming an identifiable collection entity.</p>
-
-
-<p>PROV-DM defines the following types related to collections:</p>
+<p>In PROV, the concept of Collection is provided as an extensibility point for other kinds of collections. Collections are implemented by means of dictionaries, which are introduced next. </p>
+
+</section>
+
+<section id="term-dictinonary">
+<h3>Dictionary</h3>
+
+
+<p>PROV-DM defines a specific type of collection: a dictionary, specified as follows.</p>
+
+
+<span class="glossary-ref" data-ref="glossary-dictionary"></span>
+
+<p>Conceptually, a dictionary has a logical structure consisting of key-entity pairs. This structure is often referred to as a <em>map</em>, and is a generic indexing mechanism that can abstract commonly used data structures, including associative lists (also known as "dictionaries" in some programming languages), relational tables, ordered lists, and more. The specification of such specialized structures in terms of key-value pairs is out of the scope of this document.</p>
+
+<p>A given dictionary forms a given structure for its members. A different structure (obtained either by insertion or removal of members) constitutes a different dictionary. Hence,
+ for the purpose of provenance, a dictionary entity is viewed as a snapshot of a structure. Insertion and removal operations result in new snapshots, each snapshot forming an identifiable dictionary entity.</p>
+
+
+<p>PROV-DM defines the following types related to dictionaries:</p>
<ul>
- <li> <span class="name">prov:Collection</span> denotes an entity of type collection, i.e. an entity that can participate in relations amongst collections;
-
- <li><span class="name">prov:EmptyCollection</span> denotes an empty collection.
+ <li> <span class="name">prov:Dictionary</span> denotes an entity of type dictionary, i.e. an entity that can participate in relations amongst dictionaries;
+
+ <li><span class="name">prov:EmptyDictionary</span> denotes an empty dictionary.
</ul>
@@ -2069,22 +2082,22 @@
<!--
-In addition, the attribute <span class="name">prov:content</span> is introduced to allow the explicit specification of the collection's content. The example below illustrates the syntax.
+In addition, the attribute <span class="name">prov:content</span> is introduced to allow the explicit specification of the dictionary's content. The example below illustrates the syntax.
-->
<div class="anexample">
<pre class="codeexample">
-entity(c0, [prov:type="prov:EmptyCollection" %% xsd:QName]) // c0 is an empty collection
-entity(c1, [prov:type="prov:Collection" %% xsd:QName]) // c1 is a collection, with unknown content
+entity(d0, [prov:type="prov:EmptyDictionary" %% xsd:QName]) // d0 is an empty dictionary
+entity(d1, [prov:type="prov:Dictionary" %% xsd:QName]) // d1 is a dictionary, with unknown content
</pre>
</div>
-</section> <!-- end of collection-types -->
-
-
-<section id="term-collection-insertion">
+</section> <!-- end of dictionary-types -->
+
+
+<section id="term-dictionary-insertion">
<h3>Insertion</h3>
<span class="glossary-ref" data-ref="glossary-insertion"></span>
@@ -2094,11 +2107,11 @@
<p><div class="attributes" id="attributes-derivedByInsertionFrom">
-<p>An <dfn title="derivedByInsertionFrom">Insertion</dfn> relation<span class="withPn">, written <span class="pnExpression">derivedByInsertionFrom(id, c2, c1, {(key_1, e_1), ..., (key_n, e_n)}, attrs)</span>,</span> has:</p>
+<p>An <dfn title="derivedByInsertionFrom">Insertion</dfn> relation<span class="withPn">, written <span class="pnExpression">derivedByInsertionFrom(id, d2, d1, {(key_1, e_1), ..., (key_n, e_n)}, attrs)</span>,</span> has:</p>
<ul>
<li><span class='attribute' id="derivedByInsertionFrom.id">id</span>: an OPTIONAL identifier identifying the relation;</li>
-<li><span class='attribute' id="derivedByInsertionFrom.after">after</span>: an identifier (<span class="name">c2</span>) for the collection <em>after</em> insertion; </li>
-<li><span class='attribute' id="derivedByInsertionFrom.before">before</span>: an identifier (<span class="name">c1</span>) for the collection <em>before</em> insertion;</li>
+<li><span class='attribute' id="derivedByInsertionFrom.after">after</span>: an identifier (<span class="name">d2</span>) for the dictionary <em>after</em> insertion; </li>
+<li><span class='attribute' id="derivedByInsertionFrom.before">before</span>: an identifier (<span class="name">d1</span>) for the dictionary <em>before</em> insertion;</li>
<li><span class='attribute' id="derivedByInsertionFrom.key-entity-set">key-entity-set</span>: the inserted key-entity pairs <span class="name">(key_1, e_1)</span>, ..., <span class="name">(key_n, e_n)</span> in which each <span class="name">key_i</span> is a <a>value</a>, and <span class="name">e_i</span> is an identifier for the entity that has been inserted with the key;
each <span class="name">key_i</span> is expected to be unique for the key-entity-set;
</li>
@@ -2107,8 +2120,8 @@
</div>
<p>
-An Insertion relation <span class="name">derivedByInsertionFrom(id, c2, c1, {(key_1, e_1), ..., (key_n, e_n)})</span> states that <span class="name">c2</span> is the state of the collection
-following the insertion of pairs <span class="name">(key_1, e_1)</span>, ..., <span class="name">(key_n, e_n)</span> into collection <span class="name">c1</span>.</p>
+An Insertion relation <span class="name">derivedByInsertionFrom(id, d2, d1, {(key_1, e_1), ..., (key_n, e_n)})</span> states that <span class="name">d2</span> is the state of the dictionary
+following the insertion of pairs <span class="name">(key_1, e_1)</span>, ..., <span class="name">(key_n, e_n)</span> into dictionary <span class="name">d1</span>.</p>
@@ -2117,52 +2130,52 @@
<div class="anexample">
<pre class="codeexample">
-entity(c0, [prov:type="prov:EmptyCollection" %% xsd:QName]) // c0 is an empty collection
+entity(d0, [prov:type="prov:EmptyDictionary" %% xsd:QName]) // d0 is an empty dictionary
entity(e1)
entity(e2)
entity(e3)
-entity(c1, [prov:type="prov:Collection" %% xsd:QName])
-entity(c2, [prov:type="prov:Collection" %% xsd:QName])
-
-derivedByInsertionFrom(c1, c0, {("k1", e1), ("k2", e2)})
-derivedByInsertionFrom(c2, c1, {("k3", e3)})
+entity(d1, [prov:type="prov:Dictionary" %% xsd:QName])
+entity(d2, [prov:type="prov:Dictionary" %% xsd:QName])
+
+derivedByInsertionFrom(d1, d0, {("k1", e1), ("k2", e2)})
+derivedByInsertionFrom(d2, d1, {("k3", e3)})
</pre>
From this set of descriptions, we conclude:
<ul>
-<li> <span class="name">c0</span> is the set <span class="name">{ }</span>
-<li> <span class="name">c1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
-<li> <span class="name">c2</span> is the set <span class="name">{ ("k1", e1), ("k2", e2), ("k3", e3) }</span>
+<li> <span class="name">d0</span> is the set <span class="name">{ }</span>
+<li> <span class="name">d1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
+<li> <span class="name">d2</span> is the set <span class="name">{ ("k1", e1), ("k2", e2), ("k3", e3) }</span>
</ul>
</div>
-<p>Insertion provides an "update semantics" for the keys that are already present in a collection,
-since a new pair replaces an existing pair with the same key in the new collection. This is illustrated by the following example.</p>
+<p>Insertion provides an "update semantics" for the keys that are already present in a dictionary,
+since a new pair replaces an existing pair with the same key in the new dictionary. This is illustrated by the following example.</p>
<div class="anexample">
<pre class="codeexample">
-entity(c0, [prov:type="prov:EmptyCollection" %% xsd:QName]) // c0 is an empty collection
+entity(d0, [prov:type="prov:EmptyDictionary" %% xsd:QName]) // d0 is an empty dictionary
entity(e1)
entity(e2)
entity(e3)
-entity(c1, [prov:type="prov:Collection" %% xsd:QName])
-entity(c2, [prov:type="prov:Collection" %% xsd:QName])
-
-derivedByInsertionFrom(c1, c0, {("k1", e1), ("k2", e2)})
-derivedByInsertionFrom(c2, c1, {("k1", e3)})
+entity(d1, [prov:type="prov:Dictionary" %% xsd:QName])
+entity(d2, [prov:type="prov:Dictionary" %% xsd:QName])
+
+derivedByInsertionFrom(d1, d0, {("k1", e1), ("k2", e2)})
+derivedByInsertionFrom(d2, d1, {("k1", e3)})
</pre>
This is a case of <em>update</em> of <span class="name">e1</span> to <span class="name">e3</span> for the same key, <span class="name">"k1"</span>. <br/>
From this set of descriptions, we conclude:
<ul>
-<li> <span class="name">c0</span> is the set <span class="name">{ }</span>
-<li> <span class="name">c1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
-<li> <span class="name">c2</span> is the set <span class="name">{ ("k1", e3), ("k2", e2) }</span>
+<li> <span class="name">d0</span> is the set <span class="name">{ }</span>
+<li> <span class="name">d1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
+<li> <span class="name">d2</span> is the set <span class="name">{ ("k1", e3), ("k2", e2) }</span>
</ul>
</div>
</section> <!-- insertion -->
-<section id="term-collection-removal">
+<section id="term-dictionary-removal">
<h3>Removal</h3>
<span class="glossary-ref" data-ref="glossary-removal"></span>
@@ -2172,37 +2185,37 @@
<p>
<div class="attributes" id="attributes-derivedByRemovalFrom">
-<p> A <dfn title="derivedByRemovalFrom">Removal</dfn> relation, written <span class="pnExpression">derivedByRemovalFrom(id, c2, c1, {key_1, ... key_n}, attrs)</span>, has:</p>
+<p> A <dfn title="derivedByRemovalFrom">Removal</dfn> relation, written <span class="pnExpression">derivedByRemovalFrom(id, d2, d1, {key_1, ... key_n}, attrs)</span>, has:</p>
<ul>
<li><span class='attribute' id="derivedByRemovalFrom.id">id</span>: an OPTIONAL identifier identifying the relation;</li>
-<li><span class='attribute' id="derivedByRemovalFrom.after">after</span>: an identifier (<span class="name">c2</span>) for the collection <em>after</em> the deletion; </li>
-<li><span class='attribute' id="derivedByRemovalFrom.before">before</span>: an identifier (<span class="name">c1</span>) for the collection <em>before</em> the deletion;</li>
+<li><span class='attribute' id="derivedByRemovalFrom.after">after</span>: an identifier (<span class="name">d2</span>) for the dictionary <em>after</em> the deletion; </li>
+<li><span class='attribute' id="derivedByRemovalFrom.before">before</span>: an identifier (<span class="name">d1</span>) for the dictionary <em>before</em> the deletion;</li>
<li><span class='attribute' id="derivedByRemovalFrom.key-set">key-set</span>: a set of deleted keys <span class="name">key_1</span>, ..., <span class="name">key_n</span>, for which each <span class="name">key_i</span> is a <a>value</a>;</li>
<li><span class='attribute' id="derivedByRemovalFrom.attributes">attributes</span>: an OPTIONAL set (<span class="name">attrs</span>) of attribute-value pairs representing additional information about this relation.</li>
</ul>
</div>
-<p>A Removal relation <span class="name">derivedByRemovalFrom(id, c2,c1, {key_1, ..., key_n})</span> states that <span class="name">c2</span> is the state of the collection following the removal of the set of pairs corresponding to keys <span class="name">key_1...key_n</span> from <span class="name">c1</span>.
+<p>A Removal relation <span class="name">derivedByRemovalFrom(id, d2,d1, {key_1, ..., key_n})</span> states that <span class="name">d2</span> is the state of the dictionary following the removal of the set of pairs corresponding to keys <span class="name">key_1...key_n</span> from <span class="name">d1</span>.
<div class="anexample">
<pre class="codeexample">
-entity(c0, [prov:type="prov:EmptyCollection"]) // c0 is an empty collection
+entity(d0, [prov:type="prov:EmptyDictionary"]) // d0 is an empty dictionary
entity(e1)
entity(e2)
entity(e3)
-entity(c1, [prov:type="prov:Collection"])
-entity(c2, [prov:type="prov:Collection"])
-
-derivedByInsertionFrom(c1, c0, {("k1", e1), ("k2",e2)})
-derivedByInsertionFrom(c2, c1, {("k3", e3)})
-derivedByRemovalFrom(c3, c2, {"k1", "k3"})
+entity(d1, [prov:type="prov:Dictionary"])
+entity(d2, [prov:type="prov:Dictionary"])
+
+derivedByInsertionFrom(d1, d0, {("k1", e1), ("k2",e2)})
+derivedByInsertionFrom(d2, d1, {("k3", e3)})
+derivedByRemovalFrom(d3, d2, {"k1", "k3"})
</pre>
From this set of descriptions, we conclude:
<ul>
-<li><span class="name">c0</span> is the set <span class="name">{ }</span>
-<li><span class="name">c1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
-<li><span class="name">c2</span> is the set <span class="name">{ ("k1", e1), ("k2", e2), ("k3", e3) }</span>
-<li><span class="name">c3</span> is the set <span class="name">{ ("k2", e2) }</span>
+<li><span class="name">d0</span> is the set <span class="name">{ }</span>
+<li><span class="name">d1</span> is the set <span class="name">{ ("k1", e1), ("k2", e2) }</span>
+<li><span class="name">d2</span> is the set <span class="name">{ ("k1", e1), ("k2", e2), ("k3", e3) }</span>
+<li><span class="name">d3</span> is the set <span class="name">{ ("k2", e2) }</span>
</ul>
@@ -2211,24 +2224,24 @@
</section> <!-- removal -->
-<section id="term-collection-membership">
+<section id="term-dictionary-membership">
<h3>Membership</h3>
<span class="glossary-ref" data-ref="glossary-membership"></span>
<p>
-The insertion and removal relations make insertions and removals explicit as part of the history of a collection. This, however, requires explicit mention of the state of the collection prior to each operation. The membership relation removes this needs, allowing the state of a collection <span class="name">c</span> to be expressed without having to introduce a prior state.</p>
+The insertion and removal relations make insertions and removals explicit as part of the history of a dictionary. This, however, requires explicit mention of the state of the dictionary prior to each operation. The membership relation removes this needs, allowing the state of a dictionary <span class="name">c</span> to be expressed without having to introduce a prior state.</p>
<p>
<div class="attributes" id="attributes-memberOf">
A <dfn title="memberOf">membership</dfn> relation, written <span class="pnExpression">memberOf(id, c, {(key_1, e_1), ..., (key_n, e_n)}, cplt, attrs)</span>, has:
<ul>
<li><span class='attribute' id="memberOf.id">id</span>: an OPTIONAL identifier identifying the relation;</li>
-<li><span class='attribute' id="memberOf.after">after</span>: an identifier (<span class="name">c</span>) for the collection whose members are asserted; </li>
-<li><span class='attribute' id="memberOf.key-entity-set">key-entity-set</span>: a set of key-entity pairs <span class="name">(key_1, e_1)</span>, ..., <span class="name">(key_n, e_n)</span> that are members of the collection;</li>
+<li><span class='attribute' id="memberOf.after">after</span>: an identifier (<span class="name">c</span>) for the dictionary whose members are asserted; </li>
+<li><span class='attribute' id="memberOf.key-entity-set">key-entity-set</span>: a set of key-entity pairs <span class="name">(key_1, e_1)</span>, ..., <span class="name">(key_n, e_n)</span> that are members of the dictionary;</li>
<li><span class='attribute' id="memberOf.complete">complete</span>: an OPTIONAL boolean
-<a title="value">Value</a> (<span class="name">cplt</span>); if true, it indicates that no other member belongs to the collection; if false, it indicates that other members belong to the collection; if unspecified, other members MAY belong to the collection.
+<a title="value">Value</a> (<span class="name">cplt</span>); if true, it indicates that no other member belongs to the dictionary; if false, it indicates that other members belong to the dictionary; if unspecified, other members MAY belong to the dictionary.
<li><span class='attribute' id="memberOf.attributes">attributes</span>: an OPTIONAL set (<span class="name">attrs</span>) of attribute-value pairs representing additional information about this relation.</li>
</ul>
</div>
@@ -2240,35 +2253,35 @@
<div class="anexample">
<pre class="codeexample">
-entity(c1, [prov:type="prov:Collection" %% xsd:QName]) // c1 is a collection, with unknown content
-entity(c2, [prov:type="prov:Collection" %% xsd:QName]) // c2 is a collection, with unknown content
+entity(d1, [prov:type="prov:Dictionary" %% xsd:QName]) // d1 is a dictionary, with unknown content
+entity(d2, [prov:type="prov:Dictionary" %% xsd:QName]) // d2 is a dictionary, with unknown content
entity(e1)
entity(e2)
-memberOf(c1, {("k1", e1), ("k2", e2)} )
-memberOf(c2, {("k1", e1), ("k2", e2)}, true)
+memberOf(d1, {("k1", e1), ("k2", e2)} )
+memberOf(d2, {("k1", e1), ("k2", e2)}, true)
entity(e3)
-entity(c3, [prov:type="prov:Collection" %% xsd:QName])
-
-derivedByInsertionFrom(c3, c1, {("k3", e3)})
+entity(d3, [prov:type="prov:Dictionary" %% xsd:QName])
+
+derivedByInsertionFrom(d3, d1, {("k3", e3)})
</pre>
From these descriptions, we conclude:
<ul>
-<li> <span class="name">c1</span> has the following pairs as members: <span class="name">("k1", e1), ("k2", e2)</span>, and may contain others.
-<li> <span class="name">c2</span> exactly has the following pairs as members: <span class="name">("k1", e1), ("k2", e2)</span>, and does not contain any other.
-<li> <span class="name">c3</span> has the following pairs as members: <span class="name">("k1", e1), ("k2", e2), ("k3", v3)</span>, and may contain others.
+<li> <span class="name">d1</span> has the following pairs as members: <span class="name">("k1", e1), ("k2", e2)</span>, and may contain others.
+<li> <span class="name">d2</span> exactly has the following pairs as members: <span class="name">("k1", e1), ("k2", e2)</span>, and does not contain any other.
+<li> <span class="name">d3</span> has the following pairs as members: <span class="name">("k1", e1), ("k2", e2), ("k3", v3)</span>, and may contain others.
</ul>
-<p> Thus, the states of <span class="name">c1</span> and <span class="name">c3</span> are only partially known.</p>
+<p> Thus, the states of <span class="name">d1</span> and <span class="name">d3</span> are only partially known.</p>
</div>
<!-- To go to part 2
- Note that the following one cannot have at the same time an empty collection and membership relations for it, i.e., the following example is invalid:
+ Note that the following one cannot have at the same time an empty dictionary and membership relations for it, i.e., the following example is invalid:
<pre class="codeexample">
- <span class="name"> entity(c, [prov:type="EmptyCollection"])</span>
+ <span class="name"> entity(c, [prov:type="EmptyDictionary"])</span>
memberOf(c, {("k1", e1), ("k2", v2)} )
</pre>
@@ -2283,14 +2296,14 @@
<ul>
-<li>The state of a collection (i.e., the set of key-entity pairs it contains) at a given point in a sequence of operations is never stated explicitly. Rather, it can be obtained by querying the chain of derivations involving insertions and removals. Entity type <span class="name">emptyCollection</span> can be used in this context as it marks the start of a sequence of collection operations.</li>
-
-
-<li>The representation of a collection through these relations makes no assumption regarding the underlying data structure used to store and manage collections. In particular, no assumptions are needed regarding the mutability of a data structure that is subject to updates. Entities, however, are immutable and this applies to those entities that represent collections. This is reflected in the constraints listed in [[PROV-CONSTRAINTS]]. </li>
+<li>The state of a dictionary (i.e., the set of key-entity pairs it contains) at a given point in a sequence of operations is never stated explicitly. Rather, it can be obtained by querying the chain of derivations involving insertions and removals. Entity type <span class="name">emptyDictionary</span> can be used in this context as it marks the start of a sequence of dictionary operations.</li>
+
+
+<li>The representation of a dictionary through these relations makes no assumption regarding the underlying data structure used to store and manage dictionaries. In particular, no assumptions are needed regarding the mutability of a data structure that is subject to updates. Entities, however, are immutable and this applies to those entities that represent dictionaries. This is reflected in the constraints listed in [[PROV-CONSTRAINTS]]. </li>
</ul>
-</section> <!-- end collections-->
+</section> <!-- end dictionaries-->
<section id="component6">
@@ -2558,7 +2571,9 @@
<li><span class="name">prov:Collection</span></li>
-<li><span class="name">prov:EmptyCollection</span></li>
+<li><span class="name">prov:Dictionary</span></li>
+
+<li><span class="name">prov:EmptyDictionary</span></li>
</ul>