3 discussion topics:

1. New notation
2. The "complete" attribute?
3. proposed constraints
=================================



=================================
1. New notation
=================================

OLD NOTATION:

entity(d, [prov:type='prov:Dictionary'])
entity(e1)
entity(e2)
entity(e3)
memberOf(d, {("k1", e1), ("k2", e2), ("k3", e3)})

-> d contains {("k1", e1), ("k2", e2), ("k3", e3)}

entity(d1, [prov:type='prov:Dictionary'])
entity(e4)
entity(e5)
derivedByInsertionFrom(d1, d, {("k4", e4), ("k5",e5)})   

-> d1 contains {("k1", e1), ("k2", e2), ("k3", e3), ("k4", e4), ("k5",e5)}


CURRENT COLLECTION NOTATION:

entity(c, [prov:type='prov:Collection'])
entity(e1)
entity(e2)
entity(e3)
hadMember(c, e1)
hadMember(c, e2)
hadMember(c, e3)

-> Proposed: make Dictionary more consistent with this notation

entity(d, [prov:type='prov:Dictionary'])
entity(e1)
entity(e2)
entity(e3)
hadMember(d, ("k1", e1))
hadMember(d, ("k2", e2))
hadMember(d, ("k3", e3))

-> d contains {("k1", e1), ("k2", e2), ("k3", e3)}

entity(d1, [prov:type='prov:Dictionary'])
entity(e4)
entity(e5)
derivedByInsertionFrom(d1, d, {("k4", e4), ("k5",e5)})   

-> d1 contains {("k1", e1), ("k2", e2), ("k3", e3), ("k4", e4), ("k5",e5)}



=================================
2. The "Complete" attribute
=================================

OLD NOTATION:

entity(d, [prov:type='prov:Dictionary')
entity(e1)
entity(e2)
entity(e3)
memberOf(d, {("k1", e1), ("k2", e2), ("k3", e3)}, true)

-> d is the set {("k1", e1), ("k2", e2), ("k3", e3)} (and nothing more!)

entity(d1, [prov:type='prov:Dictionary'])
entity(e4)
entity(e5)
derivedByInsertionFrom(d1, d, {("k4", e4), ("k5",e5)})   

-> d1 is the set {("k1", e1), ("k2", e2), ("k3", e3), ("k4", e4), ("k5",e5)}  (or is it? yes it is, but you have to find the memberOf statement to verify this,
and this wouldn't work with the new notation)


-> To us, this is unclear, lot's of discussion, scrapping from DM, etc.
-> Proposed: change this up a bit: 2 alternatives:

ALTERNATIVE 1:

entity(d, [prov:type='prov:Dictionary', prov:complete='true'])
entity(e1)
entity(e2)
entity(e3)
hadMember(d, ("k1", e1))
hadMember(d, ("k2", e2))
hadMember(d, ("k3", e3))

-> d is the set {("k1", e1), ("k2", e2), ("k3", e3)}  (and nothing more!)

entity(d1, [prov:type='prov:Dictionary', prov:complete='true'])
entity(e4)
entity(e5)
derivedByInsertionFrom(d1, d, {("k4", e4), ("k5",e5)})   

-> d1 is the set {("k1", e1), ("k2", e2), ("k3", e3), ("k4", e4), ("k5",e5)} (yes, it is, because it says it's prov:complete!)

Advantages:
+ directly available knowledge for the user
+ this allows us to drop the class EmptyDictionary! (because a prov:complete Dictionary without hadMember statements is empty)
Disadvantage:
- introduce new attribute
- extra constraints for complete dictionaries

ALTERNATIVE 2:

entity(d, [prov:type='prov:EmptyDictionary'])

-> d is an empty set

entity(d1, [prov:type='prov:Dictionary'])
entity(e1)
entity(e2)
entity(e3)
derivedByInsertionFrom(d1, d, {("k1", e1), ("k2",e2), ("k3",e3)})   

-> d1 is the set {("k1", e1), ("k2", e2), ("k3", e3), ("k4", e4), ("k5",e5)} 
(yes, it is, because it was derived from an empty collection)

Advantages:
+ shorter/more elegant notation
+ no new attributes
+ consistency with EmptyCollection/Collection
+ easier to form constraints
Disadvantage:
- user has to derive completeness himself



=================================
3. Proposed Constraints
=================================

------
Typing
------
cfr. PROV-CONSTRAINTS 

------------------
Insertion/removal:
------------------

IF hadMember(d1, ("k1",e1)) AND derivedByInsertionFrom(d2, d1, ("k2", e2)) THEN hadMember(d2, ("k1", e1)) holds

IF derivedByInsertionFrom(d2, d1, ("k2", e2)) THEN hadMember(d2, ("k2", e2)) holds

IF derivedByRemovalFrom(d2, d1, ("k1", e1)) THEN hadMember(d1, ("k1",e1)) holds

IF derivedByRemovalFrom(d2, d1, ("k1", e1)) THEN hadMember(d2, ("k1",e1)) THEN INVALID

---------------------------------------------------------------------------------------------------
A dictionary must not be derived through multiple insertion or removal relations.
---------------------------------------------------------------------------------------------------

IF derivedByRemovalFrom(d2, d1, ("k1", e1)) AND derivedByInsertionFrom(d2, d1, ("k2", e2)) THEN INVALID

IF derivedByInsertionFrom(d2, d1, ("k1", e1)) AND derivedByInsertionFrom(d2, d1, ("k2", e2)) THEN INVALID

IF derivedByRemovalFrom(d2, d1, ("k1", e1)) AND derivedByRemovalFrom(d2, d1, ("k2", e2)) THEN INVALID

----------
Derivation
----------
IF derivedByRemovalFrom(d2, d1, ("k1", e1)) THEN wasDerivedFrom(d2, d1) holds

IF derivedByInsertionFrom(d2, d1, ("k1", e1)) THEN wasDerivedFrom(d2, d1) holds

-------------------------------------
Depending if alternative 2 is chosen:
-------------------------------------

IF hasMember(d,e) and 'prov:EmptyDictionary' \in typeOf(d) THEN INVALID.

Insertions do not break completeness:
IF 'prov:EmptyDictionary' \in typeOf(d1) AND derivedByInsertionFrom(d2, d1, {("k1", e1)}) AND derivedByRemovalFrom(d3, d2, {("k1", e1)}) THEN 'prov:EmptyDictionary' \in typeOf(d3) 

Is this last constraint enough to guarantee completeness? Todo, formalize this:
IF derivedByInsertionFrom(d2, d1, {("k1", e1)}) AND derivedByRemovalFrom(d3, d2, {("k1", e1)}) THEN d3 only contains all members of d1