OPID: Object-Centric Petri Nets with Identifiers

• OPID is a Petri-net based formalism that explicitly models object identities and inter-object relationships, addressing limitations in traditional OCPNs for conformance checking.
• It leverages tuple-valued tokens and inscription-based arc constructs to enforce identity-sensitive synchronization and preserve relational invariants during process execution.
• OPID’s alignment framework uses SMT encoding to compute optimal conformance checking, bridging discovered OCPNs and rigorous identifier-aware modeling under stable relationship assumptions.

Searching arXiv for papers on OPID and closely related object-centric Petri net formalisms. Object-Centric Petri Nets with Identifiers (OPID) are a Petri-net-based formalism for object-centric process modeling in which places, transitions, and arc inscriptions jointly represent not only control-flow and multiple object types, but also explicit object identities and relations between objects. OPIDs were introduced to combine two previously separate modeling capabilities: the support of object-centric Petri nets (OCPNs) for multiple object types and one-to-many flows via variable or list-based constructs, and the support of Petri nets with identifiers (PNIDs) for identity-sensitive synchronization and relation tracking (Gianola et al., 2023). In this sense, OPIDs occupy a position between discovery-oriented OCPNs and more general identifier-aware Petri-net theories: they make object identity explicit enough for synchronization-aware conformance checking, while remaining close to the object-centric process mining setting in which event logs refer to multiple interacting objects rather than a single case identifier (Aalst et al., 2020).

1. Conceptual position within object-centric process modeling

Object-centric process mining emerged from the observation that many information systems cannot be faithfully analyzed under the assumption that each event belongs to exactly one case. Instead, an event may concern several intertwined objects, such as orders, items, packages, customers, or products, each with its own lifecycle and dependencies (Aalst et al., 2020). OCPNs were introduced as a corresponding process model: they type places by object type and allow transitions to consume and produce collections of objects of different types (Aalst et al., 2020).

The practical limitation of OCPNs is that they are intentionally underspecified about object relationships. They can represent that objects of several types co-occur in activities and that transitions bind objects, but they do not explicitly preserve pairwise or tuple-based relations such as “product $p$ belongs to order $o$” in the token structure. As a result, OCPNs can replay behavior in which objects are effectively reshuffled across relationship partners, even when such behavior violates the intended synchronization constraints of the domain (Seidel et al., 18 Aug 2025).

OPIDs were introduced precisely to address this gap. The core idea is to combine OCPNs with PNIDs so that one retains object-centric modeling features such as one-to-many flows, while also encoding identities and relations directly in tokens and inscriptions (Gianola et al., 2023). This makes it possible to express and analyze synchronization conditions that depend on which exact objects are involved, rather than only on their types or cardinalities. A central motivation is conformance checking: logs may exhibit the right activities and object types, yet still be incorrect because the wrong objects were synchronized together (Gianola et al., 2023).

This suggests a useful conceptual distinction. OCPNs primarily capture the flow of object types through a process; OPIDs additionally capture the identity structure of that flow. A plausible implication is that OPIDs are better suited for prescriptive analysis tasks such as precise conformance checking, while OCPNs remain advantageous when discoverability and scalable replay are the primary concerns.

2. Formal structure and token model

In the OPID formalism, a net is defined as

$N = ( \Sigma, P, T, in, out, color, \ell)$

where $\Sigma$ is a set of object types, $P$ is a finite set of places, $T$ is a finite set of transitions, $color : P \to \mathcal{C}$ assigns a color to each place, $\ell : T \to A \cup \{\tau\}$ labels transitions by activities or $\tau$, and $in$ and $o$0 are inscription-based flow functions (Gianola et al., 2023). The critical difference from OCPNs lies in the use of inscriptions on arcs and tuple-valued tokens in places.

Each place has a color given by a Cartesian product of types. Hence, a token is not merely an anonymous marker and not necessarily a single object identifier; it may be a tuple such as $o$1, representing an explicit relation between two objects, or $o$2, representing a higher-arity relation (Gianola et al., 2023). This tuple-based encoding is what enables OPIDs to remember identity-sensitive associations across transitions.

Arc inscriptions are tuples of variables,

$o$3

subject to the restriction that at most one component is a list variable (Gianola et al., 2023). The paper distinguishes normal variables for single objects, list variables for lists of objects of the same type, and fresh-object variables for newly created objects (Gianola et al., 2023). Inscriptions without a list variable are simple inscriptions; those with one list variable are template inscriptions (Gianola et al., 2023).

This design places OPIDs in a broader family of identifier-aware Petri nets. The more general t-PNID formalism uses place types $o$4 and arc annotations $o$5, with tokens carrying vectors of identifiers and bindings instantiating typed variables (Werf et al., 2022). OPIDs can be understood as a specialized object-centric member of this wider PNID family, tuned to process mining concerns such as object types, one-to-many flows, and conformance alignments. The 2025 work on DOPIDs explicitly characterizes OPIDs as the most advanced PNID-based object-centric process formalism before the addition of structured data and exact synchronization (Gianola et al., 21 May 2025).

A related point is that OCPNs themselves are already identifier-aware at the semantic level, because markings contain typed object tokens $o$6 and transition firing selects bindings over object identifiers (Benzin et al., 2023). However, in OCPNs the identifiers are carried as token content relative to place types, whereas in OPIDs identities and relations become a first-class modeling layer through tuple colors and inscription semantics. That extra layer is what permits direct representation of object relations rather than only per-type object flow.

3. Semantics of bindings, firing, and synchronization

The operational semantics of OPIDs is based on markings, bindings, and inscription instantiation. A marking is a mapping

$o$7

assigning to each place a set of correctly typed tokens (Gianola et al., 2023). To fire a transition, one needs a type-preserving binding

$o$8

where $o$9 and $N = ( \Sigma, P, T, in, out, color, \ell)$0 denote variables appearing in the input and output inscriptions of the transition (Gianola et al., 2023).

Bindings must respect typing, and fresh-object variables must be assigned to new objects not already present in the marking; the binding is injective on such fresh variables (Gianola et al., 2023). The binding extends to each inscription as $N = ( \Sigma, P, T, in, out, color, \ell)$1. For a simple inscription, this yields a singleton tuple; for an inscription containing a list variable, it yields a set of tuples, one for each object in the list (Gianola et al., 2023). A transition $N = ( \Sigma, P, T, in, out, color, \ell)$2 with binding $N = ( \Sigma, P, T, in, out, color, \ell)$3 is enabled if every instantiated input token is present: $N = ( \Sigma, P, T, in, out, color, \ell)$4 Firing removes instantiated input tokens and adds instantiated output tokens (Gianola et al., 2023).

The semantic significance of this mechanism is that synchronization depends on object identity. If a place stores a token such as $N = ( \Sigma, P, T, in, out, color, \ell)$5, then a later transition can require precisely that paired order-product relation. This prevents the model from treating any order and any product of the right types as interchangeable. The formalism therefore supports synchronization “based on whether the same object is involved” (Gianola et al., 2023).

The 2023 OPID paper states that the formal model directly supports subset synchronization rather than full exact synchronization (Gianola et al., 2023). A transition can require some related objects to participate, but exact synchronization is not built natively into the transition semantics. The later DOPID work identifies this as one of the major limitations of OPIDs, noting that OPIDs support subset synchronization but not full exact synchronization in the modeling language (Gianola et al., 21 May 2025). DOPIDs then add $N = ( \Sigma, P, T, in, out, color, \ell)$6-template inscriptions and an enablement condition that forces consumption of all matching tokens (Gianola et al., 21 May 2025). This clarifies that OPID’s synchronization power is substantial but not maximal within the identifier-aware object-centric lineage.

The contrast with OCPNs is instructive. OCPN semantics also uses bindings over object identifiers: $N = ( \Sigma, P, T, in, out, color, \ell)$7 with tokens of the form $N = ( \Sigma, P, T, in, out, color, \ell)$8 and bindings ranging over object types adjacent to a transition (Aalst et al., 2020). Yet OCPNs remain weaker for identity-sensitive synchronization, because they do not elevate relational tuples and inscription-based identity constraints to the same degree as OPIDs. This difference is the technical source of OPID’s stricter handling of object relationships.

4. Conformance checking and alignment semantics

One of the central uses of OPIDs is conformance checking through alignments. Traditional alignment-based conformance assumes a single case trace. Object-centric processes violate that assumption because one execution involves multiple interacting objects and is more naturally represented as a graph extracted from object co-occurrence relations (Liss et al., 2023). The object-centric alignments literature therefore defines process executions as connected components of the object graph and alignment structures as partial-order, object-aware correspondences between observed executions and valid model behavior (Liss et al., 2023).

For OCPNs, an object-centric alignment is a directed acyclic graph of moves whose log part is isomorphic to the observed process execution and whose model part corresponds to a valid binding sequence in the accepting OCPN (Liss et al., 2023). A synchronous move requires equality of both the activity and the involved object set: $N = ( \Sigma, P, T, in, out, color, \ell)$9 This already preserves object identity explicitly in the alignment formalism (Liss et al., 2023).

The OPID alignment framework generalizes this approach to identifier- and relation-aware models. An object-centric event log is first transformed into a trace graph $\Sigma$0 for each connected component of the object graph (Gianola et al., 2023). An alignment is then an acyclic directed graph of moves such that its log projection is isomorphic to the trace graph and its model projection corresponds to a valid OPID run (Gianola et al., 2023). Synchronous moves require equality of both activity label and object set, so the alignment respects not only control-flow but also object participation (Gianola et al., 2023).

The cost model is likewise object-sensitive. In OPID conformance checking, a log move $\Sigma$1 has cost $\Sigma$2, a model move $\Sigma$3 has cost $\Sigma$4 if $\Sigma$5 and otherwise $\Sigma$6, and a synchronous move has cost $\Sigma$7 (Gianola et al., 2023). Thus deviations involving more objects are penalized more heavily. The conformance task is to compute optimal alignments, i.e. alignments of minimum total cost, for all trace graphs in the log (Gianola et al., 2023).

The practical significance of OPID alignments becomes evident in the mismatch examples emphasized by the literature. An OCPN-based conformance technique may accept behavior in which products are swapped between orders because it sees only that shipping involved an order and a product. OPIDs can detect the deviation because tokens can store the relation $\Sigma$8 and transitions can require preservation of that relation (Gianola et al., 2023). Similarly, object-centric alignment without identity-sensitive relation tracking may miss inter-object inconsistencies that only become visible when the whole connected execution is aligned jointly rather than after flattening into single-object traces (Liss et al., 2023).

This suggests that the main analytical gain of OPID-based conformance is not only improved event matching, but preservation of relational invariants across the alignment. A plausible implication is that OPIDs are particularly valuable in settings where correctness depends on stable partnerships, allocations, or membership relations among objects.

5. Algorithmic realization and computational properties

The OPID conformance-checking approach is based on an SMT encoding (Gianola et al., 2023). The method first fixes a bound on the size of an optimal alignment, using the number of event-object occurrences in the trace graph, the number of object occurrences in a run, and the maximum length of silent-transition sequences (Gianola et al., 2023). Within that bound, the algorithm encodes the search for an optimal alignment as a satisfiability and optimization problem.

The encoding uses several classes of variables: transition variables identifying which transition fires at each step, marking variables indicating token presence at places, object variables for instantiated objects, a run-length variable, and distance variables for dynamic-programming-based cost accumulation (Gianola et al., 2023). Constraints enforce the initial marking, final marking, transition semantics, type correctness, and freshness of $\Sigma$9-objects (Gianola et al., 2023). The alignment cost is then encoded through an edit-distance-style recurrence,

$P$0

and the solver minimizes the final distance (Gianola et al., 2023).

The implementation described in the OPID paper is oCoCoMoT, built as a branch of CoCoMoT and using Yices 2 as the SMT backend (Gianola et al., 2023). The reported evaluation uses BPI 2017 data restricted to the most frequent 50% of activities, with 715 trace variants after filtering; traces had 3 to 23 events, average 12, and 2 to 11 objects, average 5 (Gianola et al., 2023). Runtime averaged about 200 seconds and reached up to about 7900 seconds in the worst case, increasing with the number of events, objects, and alignment cost (Gianola et al., 2023).

These computational observations are consistent with earlier object-centric alignment results for OCPNs. The OCPN alignment paper reports that runtime grows exponentially with the number of objects, the length of the process execution, and the cost of the alignment (Liss et al., 2023). In its evaluation on 755 variants from BPI 2017, costs ranged from 0 to 5, variants had 3 to 20 events and 2 to 7 object instances, and runtime ranged from 0.007 seconds to 1051.8 seconds (Liss et al., 2023). The OPID approach solves a strictly richer problem, so higher cost is unsurprising (Gianola et al., 2023).

The later DOPID work extends the SMT approach to data-aware OPIDs, introducing additional variables for data values and data stores and encoding guards over arithmetic, strings, uninterpreted functions, and aggregations (Gianola et al., 21 May 2025). This confirms that the OPID alignment paradigm is not a one-off construction but the basis of a broader computational framework for increasingly expressive object-centric models.

6. Relationship to OCPN discovery, stable relationships, and OPID discovery

A central issue in the development of OPIDs is discoverability. OCPNs are discovery-friendly: the standard discovery pipeline flattens the log per object type, discovers a sound workflow net per flattened view, merges the results, types the places, detects variable arcs, and returns an accepting OCPN (Aalst et al., 2020). This generic approach is implemented in PM4Py-MDL and can discover holistic object-centric models from OCEL-style data (Aalst et al., 2020).

However, the same discovery pipeline is structurally limited. The merge-by-label assumption can produce unsound models in collaborative systems, especially when the same activity label appears in different interaction contexts around loops (Benzin et al., 2023). The extended OCPD work shows that the base pipeline

$P$1

may yield unsound OCPNs or spurious interactions, and proposes relabeling and transformation-based extensions that restore soundness for the problematic loop subpattern under the Inductive Miner (Benzin et al., 2023). This is relevant to OPIDs because OPIDs are often obtained downstream from OCPNs; any unsoundness or oversynchronization already present in the OCPN can propagate into later formalization steps.

The 2025 paper on stable relationships addresses the discovery gap directly. It states that OCPNs remain underspecified about the relationships of objects and therefore cannot represent synchronization correctly, while OPIDs can explicitly represent object identities and relationships but had no discovery approach (Seidel et al., 18 Aug 2025). Its contribution is to bridge this gap using explicit stable many-to-one relationships and a rigorous mapping from OCPNs to OPIDs (Seidel et al., 18 Aug 2025).

The paper first defines stable many-to-one relationships through a co-occurrence function

$P$2

and declares $P$3 stable when for every object $P$4 of type $P$5,

$P$6

This means each many-side object consistently co-occurs with exactly one one-side object of the related type (Seidel et al., 18 Aug 2025).

On that basis, the paper gives two mappings. The baseline mapping translates an accepting OCPN into an OPID that reproduces the original replay behavior while carrying identifiers explicitly (Seidel et al., 18 Aug 2025). The synchronizing mapping then enriches the OPID with link places, link creation transitions, and auxiliary places so that stable many-to-one relationships become explicit tokens and relevant transitions must read the appropriate link token before firing (Seidel et al., 18 Aug 2025). The main result is that the original OCPN and the resulting OPID coincide on executions that satisfy the intended stable relationships, while executions violating those relationships are rejected by the synchronized OPID (Seidel et al., 18 Aug 2025).

This is a significant step for the status of OPIDs. Rather than being only a hand-crafted modeling language for conformance analysis, OPIDs become obtainable from discovered OCPNs under explicit relationship assumptions. The paper includes a proof-of-concept implementation whose input is an OCPN in JSON format and a user-supplied set $P$7 of stable many-to-one relationships, and whose output includes PNML for OPID conformance checking and DOT for visualization (Seidel et al., 18 Aug 2025).

7. Theoretical generalizations, limitations, and extensions

From a theoretical perspective, OPIDs belong to the broader family of Petri nets with identifiers, in which tokens carry references to object instances and correctness must account for object lifecycles rather than only anonymous control-flow (Werf et al., 2022). The t-PNID framework introduces identifier soundness as the conjunction of proper type completion and weak type termination, requiring that objects disappear cleanly when collected and that every present identifier can eventually be removed (Werf et al., 2022). It also shows that identifier soundness is undecidable in general, even though bounded subclasses admit decidable verification and model checking (Werf et al., 2022).

These results matter for OPIDs because they locate OPIDs within a landscape where expressiveness and analyzability are in tension. OPIDs gain modeling power by making object identities and relations explicit, but PNID-style expressiveness also brings undecidability phenomena and verification complexity. The OPID literature therefore emphasizes bounded, solver-based conformance rather than complete generic verification (Gianola et al., 2023).

A further limitation is synchronization expressiveness. OPIDs support subset synchronization, but not exact synchronization as a native modeling feature (Gianola et al., 21 May 2025). DOPIDs address this by introducing structured data, guards, and $P$8-template inscriptions that require consumption of all matching tokens (Gianola et al., 21 May 2025). The DOPID tuple

$P$9

strictly extends OPIDs with data-value types, mixed object/data colors, and guard formulas over arithmetic, strings, uninterpreted functions, and aggregates (Gianola et al., 21 May 2025). This extension makes it possible to model not only identity-sensitive synchronization but also data-aware decision logic and full exact synchronization (Gianola et al., 21 May 2025).

Another limitation concerns discoverability. The stable-relationship mapping shows how to obtain OPIDs from OCPNs under explicit assumptions, but it also makes clear that OPID discovery is not yet the same as direct end-to-end discovery from raw logs without intermediate modeling hypotheses (Seidel et al., 18 Aug 2025). The reliance on stable many-to-one relationships indicates that currently available methods target a structured but restricted class of relational behavior.

A common misconception is that OCPNs and OPIDs differ only syntactically because both involve object identifiers at runtime. The literature does not support that view. OCPNs indeed manipulate typed object tokens and bindings over identifiers (Aalst et al., 2020, Benzin et al., 2023), but they remain underspecified about explicit object relationships and intended synchronization (Seidel et al., 18 Aug 2025). OPIDs add tuple-based places and inscriptions that preserve those relations in the state space itself (Gianola et al., 2023). The distinction is therefore semantic, not merely notational.

A second misconception is that OPIDs already provide full synchronization. The formalism introduced in 2023 does not; it provides subset synchronization, while exact synchronization can arise only indirectly in specific conformance settings (Gianola et al., 2023). The DOPID work explicitly identifies the absence of native exact synchronization in OPIDs as a limitation and proposes a strict extension to remedy it (Gianola et al., 21 May 2025).

Taken together, these developments position OPIDs as a pivotal formalism in object-centric process mining. They are more expressive than OCPNs for identity-sensitive analysis, more tailored to process mining than general PNID theories, and sufficiently structured to support SMT-based conformance checking and, under stable relationship assumptions, a principled bridge from discovered OCPNs to synchronization-aware identifier models (Gianola et al., 2023, Seidel et al., 18 Aug 2025).