Lines 960/961 state "All entities-related classes are ultimately SCEElements and as such have a name, id, URI." SCEElement in the SCE Metamodel has the following attributes: name, id, aliasID, and humanID. There is no URI.

All "Adornment Value" links in section 8.7.1 resolve back to the Adornment Value header 8.7.1.1. They do not provide more information.
All "Annotation" links in section 8.7.2 resolve back to the "Annotation" header 8.7.1.2. They do not provide more information.

PPMN should reuse SCE definition, remove from PPMN

SCE is replacing the SCEVocabulary element with the SCEKindSet element (and related elements).
PPMN uses the vocabulary mechanism and thus will need to be updated appropriately.

SCE is replacing the SCEVocabulary element with the SCEKindSet element (and related elements).
PMN uses the vocabulary mechanism and thus will need to be updated appropriately.

The SCE content is defined in the SCE specification (bmi/21-12-09).

Annotation and tAnnotation are defined in both PPMN and SCE Semantics XSD.

Recommend PPMN remove definitions and reuse SCE definition

Section 6.6 Structure of this Document overviews SDMN dtc/22-01-03 and its clauses. Rather, its topic should be PPMN and its clauses.

Unlike other relationships this has subclasses for the different types of derivation. But also a DerivationKind (though indirectly linked via DerivationType) with largely the same Library of instances (DerivedFrom, QuotedFrom, RevisionOf, SourcedFrom), though missing subclass DescendantOf (which is self-referentially defined).

BTW there's a missing word "one" in the following under Figure 24
"DerivationTypes support the definition of the expected kinds of derivations that might result in the generation of one EntityType from or more others."

Line 1105 refers to property outputEntities (plural). The property is singular output Entity and represents a collection. It must be noted that the symmetrical propety inputEntity is written in the singular form within the same paragraph.

It's unclear how to use Snapshot generally, and how the creationDate is supposed to tie in with the Occurrence(s) that updated it.

The scope of a snapshot is not clear, and EntityRelationship is not timestamped in the same way.
If an Occurrence creates and removes some EntityRelationships involving an Entity, how is that represented? ActivityOccurrence::resultingEntityRelationship is not sufficient.

It's not clear what isUnique means in practice. For example 8.4.9, what does it mean for a ResponsibilityRelationship to be unique?
I assume it means unique to a specific Entity (it should say) but, if isUnique=true, does it allow any time overlap of responsibilities? What if the responsibility is delegated - won't the original still hold?

It inherits source and target but does not explain the meaning of the direction. I'd guess that the target is the more canonical and the source is the alternate but it should be spelled out.

PPMN section 6.6: Structure of this Document incorrectly copied section 6.6 of SDMN and its clauses.

The description of Entity attribute part which is a derived attribute says: the Entity or Entities that is/are contained by the Entity.
This may be ambiguous and misleading since the notion of containment differs from the notion of composition. The attribute part is derived so we should be explicit about its computation which in this case is the collection of all EntityRelationships of kind Composition from SCE ElementRelationship RelationshipKind.

Lines 1006 uses the class name EntityTypeRelationship which does not exist.

The description of attribute part of EntityType is ambiguous and needs elaboration. Additionally, part refers to the notion of composition while containment, a different concept, is mentioned in the text.

Line 1006 is the only reference to EntityTypeRelationship. This raises the question around the two class names "EntityRelationshipType" and "EntityTypeRelationship" mentioned in the same section 8.1.4. Combined with the fact that fig. 3 shows a derived attribute "part" for EntityTypes, i.e. an aggregation of Composition RelationshipKind amongst associations of an EntityType instance suggest we are missing some constructs in the diagram. At the very least, I believe a clearer text explanation is warranted.

At line 3574, the bookmark "RelationshipKinds" jumps to section 12.1.2 SCEElement. It does not provide any additional information about RelationshipKinds.

The initial text in chapter 8 is redundant with the text in chapter 7. One or the other should be changed to remove the redundancy.

Specification says "All elements in PPMN are specializations of SCE BaseElement directly or NamedElement." This is not the case. PPMN elements specialize SCERootElement.

Lines 908 and 909 specify that all elements in PPMN are specializations of SCE BaseElement or NamedElement. The SCE Metamodel has neither.

Line 906 specifies: The PPMN specification is organized into a "number" of packages. Although minor and perhaps subjective, the statement might be clearer and more meaningful by stating "set of packages".

1. PPMN Class specifies a fill of light yellow. It is, in fact, a radial gradient. The border is a solid black line, but there is a bottom-right shadow that is not mentioned. If it is immaterial, it should be explicit, like "may or may not have a bottom-right shadow."

2. Parties Class is specified correctly and is consistent with the diagrams, but it differs from all others. For example, it has no fill gradient or shadow.

3. Why "Parties General Class"? Why not just "Parties Class"?

4. "Parentheses" is misspelled.

5. SCE Class has a radial gradient fill rather than solid, as implied. The figure in the table features a grey line. In diagrams, when an SCE class appears in a PPMN diagram, it has a solid black line. When shown in a diagram belonging to the SCE package, it has a grey line.

6. External class fill is light-colored radial gradient grey.

Occurrences need the ability to aggregate Occurrences sub-Occurrences without having them necessarily be in a sub-chain. This supports the tying together of different types of Occurrences such as a Custody Occurrence and a Pedigree Occurrence. An example is the loading of grain from a farm into a shipping truck that already has grain in it. This is a combination of the grain as well as custody of the grain passing from the farm or depot to the shipping company.

Table 4 includes the following acronyms:
BHMN : not used anywhere in this specification
SDMNDI: not used anywhere in this specification
RFC: the acronym is used but refers to "Request for Comments" rather than "Remote Function Call"

PPMN doesn't have a way to graphically show relationships between elements that are otherwise captured as attributes. An example is the location of an Entity or a Party. The metamodel supports capturing the fact that an Entity is at a location and while locations do have a graphical representation, there isn't any given graphical notation for showing that the Entity is at that location. This significantly degrades the ability to graphically show where things are in relation to one-another.

Figure 2 moves the Delegation and Additional Relationships packages beside Pedigree and Provenance packages. The two diagrams should be more consistent or one should be removed.

The content of 8.1 Entities lines 955 to 966 overlap with the content of 8.1.1 Entity.

Parties models should support creation of Org Chart type diagrams.

Annex A contains an informal mapping, but there should also be a mapping ontology, mapping to the PROV-O ontology from W3C.

They are shown on Figure 2.

The definition says "The AttributedTo relationship is a kind of AssociatedWith relationship that captures the fact that an Entity was created or transformed by some unknown activity or action of a Party."

However even if the activity detail is known, there may still be value in giving someone specific (out of all those who may have played some role) credit or responsibility for the Entity e.g. in case of support or other inquiries.

In PPMN DerivedFrom::derivee is used to represent the Entity FROM which something was derived; however in English it means the derived element - which is the other named end.
Quoting a definition:
"In linguistics, a derivee is a word that is formed from another word by adding affixes or changing the shape of the root. For example, the word "runner" is a derivee of the word "run".

In general, the word "derivee" means something that is derived from something else. The specific meaning of the word will depend on the context in which it is used.

Here are some examples of how the word "derivee" is used in a sentence:

In mathematics, the derivative of a function is its derivee.
In linguistics, the word "runner" is a derivee of the word "run"."

These terms all inherit from SCE::SemanticElement which is supposed to have a conceptURI. Though not mandatory in the metamodel it seems bad practice that none of the official library elements have such.

If only as an exemplar. For example, the standard graphical formats, HTML, PDF, programming languages, XML, XMI etc

In figure 3, UML diagram Entities and EntityTypes, the name of the association owned by EntityType should be named "typeSnapshot" rather than "snapshotType". This naming format will also maintain consistency with the name "snasphot", the association end owned by Entity.

There are several issues with line 1015 sentence starting with: "Additionally, ...": the word "contain" (spelled "conain" in the doc) is used to mean composition, the attribute "parts" is used (no need to make part plural, it is already a collection), and finally it mentions an EntityComposition relationship which does not exist.

Line 1006 reads as follows: "The kind of EntityTypeRelationship is specified by the type property inherited from ElementRelationship". There is no inheritance between these two classes.

At line 993, Table 6 the text refers to a .formatRegistry, seemingly a class, which is not modeled or referenced in the text anywhere in PPMN or SCE.

Line 1103 refers to an inherited property OccurrenceRole which does not exists. Rather, it should refer to inherited propery role which is of type OccurrenceRole

The repeated text lines are next to each other. Figure 7 which uses lines 1078 and 1080 is the only thing that separated the identical verbiage.

The statement in line 959, "Entities may represent some other thing of interest through EntityURI property," is ambiguous. What kind of relationship is "represent"? Is it a reference, correlation, or some undefined relationship? Depending on the definition of this relationship, we may introduce some inconsistencies in the metamodel.
Furthermore, table 5 in line 984 defines "entityURI" as "A URI to the Entity". This is ambiguous and difficult to reconcile with line 959.

Section 8.11 Primitives shows UUID as a primitive (line 2356). However it does not appear anywhere in the document and may be unecessary.

In Fig. 3 UML diagram Entities and Entity Types, the class representing a snapshot of an Entity Type is incorrectly named EntitySnapshotType. The correct name should be EntityTypeSnapshot, i.e. a snapshot of an entity type rather than the type of an entity snapshot. This is further underscored in line 964, where the term EntityTypeSnapshots is used.

Section 8.1 starting at line 965 contains references to EntityComposition and EntityTypeComposition relationships. These are not defined or modeled in bmi/22-09-01 or dtc/22-01-04.

The "EntityComposition relationship is referred to in the text at lines 961, 963, 965, and 1016, but is not defined in the specification and does not exist. The mechanism of composition is defined by SCE RelationshipKind class Composition.

Line 991, link to "SemanticReference" lands on section 10 "Parties Model" when it should land on section 12.6.2 SemanticReference. Perhaps it simply can be removed since section 12 SCE Model will be removed from bmi/22-09-01 and a reference to SCE might suffice.

The property creationDate in Table 9, line 1021, is unnecessary. It already exists in parent class Entity.

EntitySnapshot specifies an attribute creationDate when it already exists in its parent class Entity.

It adds nothing over EntityType

One says "Output indicates that the target Entity is an output of some kind of the Occurrence.."
and the other says "Product indicates that the source Occurrence produces or creates the target Entity during the course of the Occurrence."
It seems both Product and By-product should be subtypes of Output (should at least be documented if not supported by the metamodel) but there is no definition of what would make a Product.

It's unclear if either would encompass destroying the Entity.

That would allow for treating a whole chain as a single occurrence for purposes of abstraction/drill down, and address inconsistencies in the current metamodel (e.g. it would seem that a single Occurrence cannot have a subject Entity or interestedParty since they are properties specific to OccurrenceChain).

Many people will want to use PPMN just for tracking occurrences (which is the level that PROV works at). Understanding how to do this is made a lot more complex by the fact that all the metamodels are presented along with the type/process level information.
Proposal: have the instance/occurrence level information in their own self-contained metamodels and the Type extensions separate.

It's described in the text of 8.9 but not shown in a diagram or included in the metamodel. It seems useful, to represent the relationship from PROV.

This is one of the 4 classic types of process communication e.g. https://www.brcommunity.com/articles.php?id=b634 - we have the other 3 (input, output, enabler).

[IDEF0 uses different terms - Control instead of Guide and Mechanism instead of Enabler. Use of MVF would enable this]

At the moment people would be excluded, based on the definition "An individual concept or informational or physical artifact". However there may be use cases where it's required to track chain of custody of a person e.g. a prisoner, a baby/minor, a patient, a VIP, a witness, an asylum seeker, a dead body, a mummy. All being held and transported and transferred between parties.

It's not helped that the descriptions of the properties of OccurrenceRelationship use "dependent", and the properties of Occurrence (Table 14) use "dependency" for both predecessor (OccurrenceRelationships) and occurrenceDependency. It's pretty hard to determine what's canonical vs what's derived. I think that OccurrenceRelationship is intended to be derived from OccurrenceDependency (which involves the more detailed flow of Entities). Another confusing aspect is that OccurrenceDependency is used for outputs: the source of such Dependencies is the Occurrence rather than the Entity produced. Normally (e.g. in UML) the source of a Dependency would be an Entity and it's dependent on the Occurrence that generated/updated it. I think it might be better to rename it. Further confusing is that the PPMNLibrary has a PPMNRelationshipKind of Dependency.

At the moment it's self-referential "Custody indicates that the source element has custody of the target element."
There are nuances and legal aspects to consider.
For example, if someone is working for a company does the company or the employee have "custody" of the Entity they're working on? Legally it's the Company.
If an Entity is lost or stolen does the finder, or thief, have custody? Legally they do not, apparently.

It's not clear whether this should be in scope (probably not), but at minimum something should be said about it. There are other standards that could be used for contact info, e.g. vCard, and OMG Commons has basic support for identifiers, and the GLEIF ontology has registration information. In general there are several aspects not addressed, several important for provenance - especially being able to identify the party.

• naming
• registration (for companies)
• jurisdiction
• identification (many schemes, including for non-human agents)
• entity type (for companies, but could be used for minors/prisoners)
• date created/born and ceased
• software/hardware version (for non-human agents)

It repeats "is an input":
Input indicates that the target Entity is an input to the source Occurrence is an input during the course of the Occurrence

The definition "The time that the Occurrence had the dependency on the Entity” is unclear in usage when the Occurrences themselves have both a start and end.
I think the property could safely be deleted.

3 mentions in the text of 8.2 and 8.2.1: should be ActivityOccurrenceType

Occurrences may be linked to Locations regardless of a Party, so it does not make sense to include the Locations package in the Parties model.

Unlike PROV which makes it explicit.
All we have is creationDate, which could refer to a snapshot.

It's unclear what the sequence should be, or even the meaning of grouping the Occurrences into a Chain. Is the "succession" to be based on timing, dependency, causation? Is it an error if they are not in time sequence?
How are the occurrenceHistory related to occurrenceRelationships and/or Dependencies?

BTW the definition should say "in the life of some Entity" as opposed to "NamedElement"

Figure 52 should show AcquisitionKind inheriting from SemanticReference. the other vocabs do have this.

For example, I would have thought a Performer would always have an interest.

The initial version was created using MOF2RDF rules, which are intended for metamodel management, not a deployable ontology.
Further, the ontology could use some documentation in the specification.

This is odd and unnecessary, and could causes glitches in processing/searching

For best practice and consistency

The spec doesn't clearly specify the constraints on the types of items that can be imported for a PPMN model.

Section 6.2 in bmi/22-09-01 (PPMN), section 6.2 in dtc/22-01-04 (SCE), and section 6.1.1 in formal/2011-01-03 (BPMN) show identical typographical conventions about references to graphical, non-graphical elements, and references to attributes or model associations. However, it appears that PPMN and SCE do not implement these conventions properly, certainly not in the manner observed in BPMN.

Without those, interchange becomes less predictable.
The nsPrefixes need adding as mof:tags org.omg.xmi.nsPrefix.

The current PPMN XSDs were developed with a faulty translation of UML class relationships to the XSD elements.
To resolve this issue we need to specify the XSD patterns that correspond to the UML class relationships and then update the XSDs.

The specification includes figure 11 Occurrence kinds but the diagram is not complete and is not needed. Document number is actually dtc/22-11-05.

Remove from PPMN. PPMN reuses SCE

SCE was removed from other BPM+ specifications including PPMN and established as a separate specification. PPMN needs to reference the machine readable files associated with the new SCE specification.

The file and namespaces associated with the Parties related machine readable files of the PPMN specification currently use PM in the name and namespace rather than Parties. This has caused confusion in the community. The name should be expanded to Parties to resolve the issue.

The BKPMN language is referenced in the spec, but it is not an official language yet

DateTimeValue and tDateTimeValue is defined in both PPMN and SCE Sematics XSD.

Recommend PPMN remove definition and reuse SCE definition

PPMN should reuse SCE definitions, remove from PPMN

Remove from PPMN, PPMN reuses SCE's definition