Petri Nets with Identifiers (OPIDs)

• OPIDs are object-centric Petri nets that encode explicit object identities, enabling detailed modeling of multi-object interactions.
• They generalize classical Petri nets by enforcing synchronization constraints, such as stable many-to-one relationships, to maintain consistent object bindings.
• OPIDs facilitate efficient conformance checking and process discovery from event logs, improving diagnostics in complex, object-rich systems.

Petri Nets with Identifiers (OPIDs) are an object-centric extension of Petri nets in which tokens encode explicit object identities. OPIDs enable precise modeling, execution, and analysis of systems and processes characterized by multiple interacting object types with persistent identity, arbitrary relationships, and complex synchronization constraints. They generalize classical place/transition Petri nets by making explicit not only how many tokens (objects) of each type flow through the system but also which specific objects are involved and how their relationships and identities constrain or synchronize transitions. This formalism subsumes object-centric Petri nets (OCPNs) and can enforce constraints such as stable many-to-one relationships between object types, eliminating underspecification in standard object-centric models and allowing for conformance checking at the identity and correlation level (Seidel et al., 18 Aug 2025, Aalst et al., 2020, Werf et al., 2022, Gianola et al., 21 May 2025).

1. Formal Definition and Marking Semantics

An OPID consists of a finite set of places $P$ and transitions $T$ (with $P\cap T = \emptyset$), a finite object type set $\Sigma$, and a universe $O$ of object identifiers equipped with a type function $\operatorname{ot}: O \to \Sigma$. Each place is assigned a “color,” i.e., a tuple of types, $\operatorname{color}(p) \in \Sigma^+$, meaning it holds tuples of objects of the specified types.

Transitions are specified with input and output inscriptions (templates) over the variables of three kinds:

• $X = \{ x_\sigma \mid \sigma \in \Sigma \}$: single-object variables
• $$X_{\text{list}} = \{ X_\sigma \mid \sigma \in \Sigma \}$$: list variables (for variable-arity arcs)
• $V = \{ \nu_\sigma \mid \sigma \in \Sigma \}$: fresh object creation variables

A global marking $T$0 assigns to each place $T$1 a set $T$2 of object tuples conforming to $T$3. A transition $T$4 is enabled under a binding $T$5 if, for every place $T$6 with an incoming arc to $T$7, all the concrete object tuples matched by evaluating the inscription via $T$8 are found in $T$9. Upon firing, the corresponding objects are removed from input places and added to output places according to $P\cap T = \emptyset$0, which interprets variables to object identifiers and lists thereof, injecting new identifiers for creation variables (Seidel et al., 18 Aug 2025, Gianola et al., 21 May 2025, Aalst et al., 2020).

2. Relationship to OCPNs and the Necessity of Identifiers

Object-Centric Petri Nets (OCPNs) describe process flows involving multiple object types but lack explicit identity tracking. An OCPN places only object type and multiplicity information at each place, losing all correlation information between different types during execution. This makes them unable to express or enforce persistent binding constraints—such as ensuring a wheel is associated with a single frame throughout its lifecycle in a bicycle manufacturing process. OPIDs overcome this by encoding not only the type and count of objects but their concrete identities and associations, preserving which specific objects are synchronized by which transitions. For every run accepted by an OCPN, there may be many object-level traces corresponding to incompatible relationships; OPIDs can enforce only those compatible with specified or discovered relationships (Seidel et al., 18 Aug 2025).

3. Synchronization via Stable Object Relationships

OPIDs can express synchronization constraints over object identities, notably stable many-to-one (or more generally many-to-many) relationships. A stable many-to-one relation between types $P\cap T = \emptyset$1 asserts that every $P\cap T = \emptyset$2-object is consistently linked to exactly one $P\cap T = \emptyset$3-object throughout its run. This is formalized by introducing “link places” to represent pairs of related object identifiers, as well as synchronization transitions that guarantee transitions involving both object types only occur if the pair is present in the link place. The construction algorithm for synchronized OPIDs from OCPNs and a set of many-to-one relationships $P\cap T = \emptyset$4 guarantees:

• Only synchronized (i.e., relationship-respecting) behaviors are possible.
• Each execution in the original OCPN that respects $P\cap T = \emptyset$5 can be mapped bijectively to a run of the synchronized OPID, and vice versa.
• Violation of relationship constraints (e.g., a wheel switching frames) is detected as an enablement failure.

This enables conformance checking at the object-association level and prevents process model underspecification that could allow invalid object flows (Seidel et al., 18 Aug 2025).

4. Operational Semantics and Expressiveness

OPIDs generalize colored Petri nets by restricting colors and data operations to object identifiers, thus supporting unbounded, persistent object identity and list manipulation but forbidding arbitrary data guards and transformations. Transitions operate by bindings that map inscription variables to identifiers in the current marking, subject to type compatibility and variable arity constraints. Subset variables on input inscriptions allow for partial synchronization, supporting patterns such as picking arbitrary subsets of related objects. OPIDs support object creation via fresh variables, arbitrary joining and splitting of object sets, and multi-object synchronization (Gianola et al., 21 May 2025, Aalst et al., 2020).

Limitations include the lack of expressivity for structured data manipulation or exact synchronization (enforcing “all-and-only” synchronization in one step requires further extensions such as DOPIDs). Classical colored nets admit arbitrary data and guards; OPIDs are strictly about identifiers and relations, enabling efficient discovery from event data by tabulating object-identifier flows per event (Aalst et al., 2020, Gianola et al., 21 May 2025).

5. Correctness, Soundness, and Decidability

OPIDs inherit the rich correctness theory of Petri nets with identifiers (t-PNIDs), including notions of identifier-soundness (all objects are ultimately consumed without leakage), resource-awareness (exclusive and conservative resource assignment), and width/depth boundedness (finite use of objects per place or type). For unrestricted OPIDs (with unbounded identifier generation and arbitrary bindings), reachability, soundness, and depth-boundedness are undecidable; however, safety and model-checking become decidable on the width-bounded fragment, leveraging reductions to well-structured transition systems (Werf et al., 2022, Gianola et al., 21 May 2025).

Construction disciplines such as Typed Jackson nets provide structure-preserving transformations ensuring identifier soundness and liveness by design. The explicit representation of object identities and synchronization points allows precise object-level verification of properties across types.

6. Applications, Discovery, and Conformance Checking

OPIDs are the natural target formalism for process mining on object-centric event logs (OCEL), in which events refer to sets of objects of given types rather than a single case identifier. From such logs, OPIDs can be discovered by reconstructing flows of objects and their relationships, detecting implicit relationship constraints (like stable many-to-one associations), and encoding these into synchronized nets (Seidel et al., 18 Aug 2025, Aalst et al., 2020).

Conformance checking in OPIDs is decidable even with unbounded object identifiers due to the “folding” argument that bounds relevant firing sequences and identifier pools for a given trace. In practice, checking is efficiently implementable via SMT-based search over finite encodings (Gianola et al., 21 May 2025). Synchronized OPIDs precisely capture violations of relationship constraints, enabling fine-grained process diagnostics and compliance monitoring.

7. Extensions and Future Directions

Limitations of OPIDs motivate further extensions:

• Data-aware OPIDs (DOPIDs) extend the identifier formalism to structured data, supporting attributes, guards, and aggregation constraints (Gianola et al., 21 May 2025).
• Exact synchronization and general many-to-many constraints require richer templates or invariants.
• Methods for discovering non-existential and evolving relationships, and for handling “silent” objects whose links are not explicit in event data, are active research areas.
• Incremental or localized conformance checking methods are under investigation to scale OPID-based analysis.

OPIDs thus provide a rigorously defined, expressive, and operationally tractable framework for representing, analyzing, and reasoning about object-centric, relationship-rich, and identity-sensitive systems and processes (Seidel et al., 18 Aug 2025, Werf et al., 2022, Gianola et al., 21 May 2025).