An ER-Model-Based Framework for Case Notion Selection in Object-Centric Processes

Akhil Kumar

REVIEW 3 major objections 5 minor 19 references

An ER-Model-Based Framework for Case Notion Selection in Object-Centric Processes

T0 review · 3 major / 5 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that an ER schema can define process cases for object-centric event logs, producing a strict partition of the log by treating cases as connected components over primary and secondary entities.

desk verdict The formal partition part is sound, but the share-based resource classification fails for the paper's own motivating resource types, so the advertised advantage over connected components is shaky; still worth a referee. read the letter →

arxiv 2607.26384 v1 pith:A23IN6B2 submitted 2026-07-29 cs.DB

Akhil Kumar This is my paper · ORCID

classification cs.DB

keywords object-centricprocessminingcasenotionERschemaconnectedcomponentsentityclassificationstrictpartitiontransitiveclosurediscovery

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Object-centric event logs record several business objects per event, and there is no obvious grouping into cases—the unit that process mining needs. The paper argues that the entity-relationship schema behind the process supplies that grouping: identify one primary entity type (e.g., order), classify other types as resources (to ignore), parents (to ignore), or secondary coordinating entities (to keep), and declare each case to be one connected component of the graph whose nodes are primary and secondary objects. If this is right, the resulting cases form a strict partition of the event log, cover every execution instance exactly once, and keep resource objects from silently merging independent runs. A sympathetic reader would care because case choice determines everything downstream—discovered models, conformance checks, and per-instance performance numbers.

What carries the argument

The engine of the method is Definition 5: build an object relationship graph whose vertices are all objects except resource and parent instances, draw an edge between any two objects that co-occur in an event, then take connected components. Components serve as cases, with the case output only the PE instances, while SE* objects act as bridges that intentionally fuse coordinated PE instances. This construction carries the three advertised properties: strict partition, transitive closure, and every case anchored by a PE object. The resource class itself is selected by the share statistic—the fraction of events referencing more than one instance of a type—with a default threshold.

What would settle it

Run the method on a log where a truck or recruiter is recorded once per event but ferries several unrelated orders; if Definition 3 keeps that type in the graph (share=0) and the resulting connected components merge those orders into a single case, the advertised 'no spurious merging' property fails. More directly, one can compute share(t) over a log with known resource types and check whether the default threshold yields ET_res exactly.

Watch

Extended reading notes

Core claim

The paper's central claim (Definition 5, properties P1–P3) is that a case notion with formal guarantees can be derived from the ER schema rather than from log statistics alone. After choosing a primary entity PE, excluding resource entities (identified by a share statistic) and parent entities (1:n owners of PE), and keeping secondary entities SE* (bridge objects in m:n or 1:n coordination with PE), the connected components of the object relationship graph induce a partition of the log: every PE instance belongs to exactly one component, every event referencing at least one PE object is assigned to exactly one case, and PE instances linked through any chain of non-resource objects end up in

Load-bearing premise

The load-bearing premise is that the share statistic correctly tells which entity types are resources; if a resource type is referenced once per event, share=0, so its objects remain as bridges and independent executions can merge into one case.

Editorial extensions

If this is right

Standard process discovery algorithms can be run on the projected sub-logs, one trace per PE instance and one per SE* instance, without inventing case ids.
Joint-execution cases, where several PE instances synchronize through a shared secondary object, are represented as one case rather than being flattened away or split.
Resource objects such as catalog items do not merge independent executions, provided the resource classification is correct.
Case identifiers become stable, fixed-length hashes of the sorted PE ids, suitable as surrogate keys.
The partition reveals asymmetry invisible in the raw log: in the test log, the PE lifecycle shows 109 trace variants versus 6 for the SE lifecycle.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A testable extension is to vary θ_share across a benchmark of OCEL logs and measure how stable the resulting case partitions are; the paper tunes the threshold by hand and tests one log.
The same component-based definition could in principle be applied when the ER schema is inferred from the log rather than given, but the schema's cardinality information would have to be reconstructed from co-occurrence statistics, and the paper does not claim this.
The boundary case of PAYMENT suggests that extending SE* to transitive schema reachability would let the framework handle multi-level coordination processes (e.g., orders → invoices → payments), at the cost of deciding whether a transitively reached entity behaves as a resource or a secondary entity.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: the cleanest part of this paper is Definition 5 — cases as connected components over PE and SE* objects, with strict partition and transitive closure provable by construction. That part holds. But the resource-exclusion mechanism in Definition 3 does not do what the abstract promises. Your stress-test is right: share(t) is the fraction of events referencing more than one instance of type t, so any resource that appears once per event — a truck, a recruiter, a product — gets share=0 and is never excluded. The paper's own motivating examples are exactly these, yet Example 3 only works because ITEM happens to co-occur several times per event. The advertised advantage over full connected components collapses for the common one-resource-per-event case, and P1–P3 end up as properties of the filtered graph rather than guarantees against spurious merging.

What is genuinely new and useful: the ER-schema-guided classification into parent, secondary, and resource types is a legitimate extension of the data-driven approaches in Adams et al. and van Detten et al. The two-level discovery framing — separate PE lifecycle and SE* lifecycle sub-logs — is a clean way to exploit the schema, and the paper is honest about its limitations: single log, no ground truth, thresholds to tune, and a proposed validation via structural homogeneity H that is only sketched, not computed. The citation pattern is fair, and the link to the 1,000-event log is a plus.

Soft spots, in proportion: the share statistic is the load-bearing flaw, and it is not a minor leak. The paper keeps saying resource exclusion prevents merging of independent executions, but the definition doesn't reliably identify resources. The evaluation on one log with no baselines against Adams or van Detten would be a concern even if the classification were sound. And Section 6's homogeneity idea is future work, so it cannot serve as validation. That said, the formal connected-component machinery itself is correct, and the authors acknowledge that schema quality and threshold tuning matters.

Who this is for: researchers working on case notions in object-centric process mining, especially those who want a formal reference for partition guarantees or a starting point for fixing resource identification. I'd bring it to a reading group and would send it to peer review — a referee could push the authors toward a more robust resource classifier, maybe using ER role semantics or cardinality combined with object counts. I would not cite it for the resource-exclusion claim, though I might mention it as related work. It deserves a serious referee, but the authors need to either fix the resource definition or substantially soften the claim.

Referee Report

3 major / 5 minor

Summary. The paper proposes an ER-schema-guided framework for selecting a case notion in object-centric process mining. The framework classifies entity types as primary (PE), secondary (SE*), resource, or parent based on ER cardinalities and a log-derived share statistic, then defines cases as connected components of the object relationship graph restricted to PE and SE* objects. The authors show that this construction yields a strict partition with transitive closure by construction, and illustrate the approach on an order-management example and a 1,000-event OCEL log, followed by a two-level discovery decomposition. The central formal properties P1–P3 are indeed immediate consequences of the connected-component definition, but the paper's advertised semantic advantage — avoiding spurious merging through resource objects — depends on the robustness of the resource-classification rule, which is not established for the motivating examples.

Significance. If the classification mechanism were trustworthy, the framework would provide a principled, schema-grounded alternative to ad hoc flattening and to full connected-component case notions. The formal partition and transitive-closure guarantees are genuine and are obtained without optimization or post-processing. The paper is also honest about the need for thresholds and further validation, and it makes the evaluation log publicly available. However, the resource-classification step is the load-bearing element for the claimed 'no spurious merging' property, and it is not robust: the very resource types used to motivate the work (trucks, recruiters) are not identified by the share statistic. The proposed empirical validation (structural homogeneity) is circular, and the evaluation is limited to a single synthetic log with no baseline comparison. The formal skeleton is sound, but the advertised contribution requires a reworked resource-entity definition and a more convincing evaluation before the claims in Table 1 can be accepted.

major comments (3)

[Section 4.2, Definition 3; Section 1] The resource-exclusion mechanism fails for the paper's motivating resource types. Definition 3 sets ET_res = {t : share(t) >= theta_share}, where share(t) is the fraction of events referencing more than one instance of t. A truck or recruiter typically appears once per event, giving share(t)=0, so with default theta_share=0.3 such a type is not placed in ET_res. It therefore remains in V in Definition 5 and can act as a bridge between independent executions across events, exactly the spurious-merging failure the paper claims to avoid (Table 1, Section 6). Example 3 works only because ITEM appears multiple times per event; it does not test the truck/recruiter case. Concretely, a log with two orders and one truck, with two events (truck+order A, truck+order B), will produce one connected component even though the orders are independent, because share(truck)=0. This directly undermines the
[Section 6] The proposed validation via structural homogeneity H is circular. The baseline 'prediction' (from ER cardinality) and the actual coordination load SC are both computed from O2O edges in the same log that was also used to determine the share-based resource classification. High H therefore only confirms that the log is internally consistent with itself; it cannot independently confirm that the entity classification is correct. Moreover, H and SC are not formally defined — the text says 'These concepts should be developed in subsequent work' — so the statement that the 1,000-event log yields '40 structurally coherent cases' is an assertion rather than a validation. Provide an operational definition of H and compare against ground-truth logs or held-out data.
[Section 4.5; Section 5; Table 1] The empirical evaluation is limited to a single synthetic log with no baseline comparisons and no sensitivity analysis for the thresholds theta_share and theta_cov. The claim in Table 1 that this paper achieves 'No spurious merging: Yes' is not established by the experiments; the experiments only demonstrate the formal partition properties, which hold regardless of whether the classification is semantically correct. To support the advertised advantage over full connected components and over Adams et al. [8], the paper should report precision/recall on logs with known ground truth, compare with the full-component baseline, and test the robustness of the resource classification to threshold choices.

minor comments (5)

[Notation throughout] The paper uses 'Resource entity (RE)' in Section 3.2 but 'ET_res' in Definition 3, and 'SE' vs 'SE*' inconsistently. Please unify the notation.
[Section 4.2] The sentence 'A well-chosen PE should have high coverage and low share' is presented as a filter, but Definition 2 selects PE by domain knowledge and the statistics are only corroborative. Clarify that the thresholds are not a formal selection procedure for PE.
[Section 4.4, Remark 2] MD5 is described as 'collision-resistant'; this is not accurate in a security sense. Consider using SHA-256 or remove the term.
[Section 5] The 'arc multiplicity k' values (1 to 6) are mentioned without supporting data. Please indicate where these counts come from or include a table.
[References] References [13] and [18] are dated 2026. If these are still in press or preprints, please mark them accordingly; otherwise the citation dates appear inconsistent with the current submission year.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: the case notion is a construction with definitional guarantees; the main concerns are limitations/internal checks, not circular reductions.

full rationale

The central derivation chain (Definitions 1-6) is not circular. PE, ET_par, ET_res, and SE* are fixed inputs from the ER schema and the share statistic before the object graph is constructed; connected components then determine the case partition. P1-P3 are direct consequences of Definition 5's connected-component construction, so the strict partition and transitive-closure claims are formal entailments, not fitted predictions. The 1,000-event application in Section 4.5 is a direct execution of Definition 5 and is not an external validation, but it is also not a fitted parameter renamed as a prediction. Section 6's structural homogeneity H is explicitly deferred ('should be developed in subsequent work') and, as sketched, is an internal consistency check comparing an ER-cardinality baseline with O2O coordination load in the same log; it is not used to support the central derivation and no equation reduces it to the share-based classification. Definition 3's share statistic measures per-event multiplicity rather than across-event resource sharing, so once-per-event resources such as trucks or recruiters would not be excluded; this is a real assumption/correctness risk for the motivating examples, but it is not a circular reduction. The only self-citation is [16], used as background for many-to-many relationships in object-centric logs and not load-bearing for the framework. Overall: no significant circularity; the score reflects the minor non-load-bearing self-citation.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The framework rests on an expert-provided ER schema, a domain-chosen PE, and a log-derived share threshold; none are independently validated. The share-based resource test is especially fragile because it only detects entities that appear multiple times in a single event.

free parameters (2)

theta_share = 0.3
User-defined threshold in Definition 3 for classifying resource entities; the 40-case result depends on it, and no sensitivity analysis is provided.
theta_cov = 0.5
Default threshold in Section 4.2 for filtering PE candidates; mentioned but not systematically varied.

assumptions (4)

domain assumption The ER schema accurately represents the business process and its cardinalities.
Definitions 2 and 4 rely on card(t->PE) to classify parent/secondary entities; if cardinalities are wrong, SE* is wrong.
domain assumption The primary entity type is correctly identified from domain knowledge.
Definition 2: 'PE is the entity type t in ET that represents the primary business object of the process, as identified from the ER schema S and domain knowledge.'
domain assumption Co-occurrence of objects in an event implies a meaningful coordination relationship for case formation.
Definition 1 builds O2O from event co-occurrence, and Definition 5 treats connectedness in this graph as case membership.
ad hoc to paper share(t) >= theta_share identifies resource entities.
Definition 3; no validation that single-occurrence-per-event shared resources (trucks, recruiters) have high share; the paper's own introduction names trucks and recruiters as resources.

how reviews work

0 comments

Cite this review

Pith. "Pith review of An ER-Model-Based Framework for Case Notion Selection in Object-Centric Processes." pith.science (2026). https://pith.science/paper/A23IN6B2

@misc{pith2026260726384,
  author       = {Pith},
  title        = {Pith review of: An ER-Model-Based Framework for Case Notion Selection in Object-Centric Processes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/A23IN6B2}},
  note         = {Machine review of arXiv:2607.26384}
}

read the original abstract

Object-centric process mining operates on event logs where each event references multiple objects of different types. A fundamental challenge is defining a case notion - the grouping of events into coherent process execution instances -without which process discovery and conformance checking cannot proceed. Existing approaches either flatten the log to a single object type (losing inter-object coordination) or use the connected component of the object graph (creating overly complex cases due to resource-like objects). We propose an Entity-Relationship-schema-guided framework that identifies the primary entity (PE) type anchoring each process execution, classifies other entity types as secondary coordination entities or resources, and defines cases as connected components of the primary and secondary entity object relationship graph. The resulting case notion is shown to produce strict partitions with automatic transitive closure. The framework is illustrated with an order management process and validated on a 1,000-event OCEL log producing 40 structurally coherent cases.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

19 extracted references · 2 canonical work pages

[8]

Adams, D

J.N. Adams, D. Schuster, S. Schmitz, G. Schuh, W.M.P. van der Aalst (2022). Defining cases and variants for object-centric event data. 2022 4th International Conference on Process Mining (ICPM). IEEE, 2022

2022
[1]

van der Aalst: Process Mining: Data Science in Action

W.M.P. van der Aalst: Process Mining: Data Science in Action. Springer (2016)

2016
[2]

van der Aalst, G

W.M.P. van der Aalst, G. Li, and M. Montali (2017). Object-centric behavioral constraints. arXiv preprint arXiv:1703.05740

arXiv 2017
[3]

van der Aalst et al.: Process Mining Manifesto

W.M.P. van der Aalst et al.: Process Mining Manifesto. BPM Workshops, Springer LNBIP vol. 99 (2012) 12

2012
[4]

van der Aalst: Object-centric process mining: dealing with divergence and convergence in event data

W.M.P. van der Aalst: Object-centric process mining: dealing with divergence and convergence in event data. International Conference on Software Engineering and Formal Methods. Cham: Springer International Publishing, 2019

2019
[5]

WMP van der Aalst & A. Berti. Discovering Object-centric Petri Nets. Fundamenta Informaticae. 2020;175(1-4):1-40. doi:10.3233/FI-2020-1946

doi:10.3233/fi-2020-1946 2020
[6]

van der Aalst

W.M.P. van der Aalst. Object-centric process mining: unraveling the fabric of real processes. Mathematics, 11.12 (2023), 2691

2023
[7]

Adams, A

J.N. Adams, A. Schuster, W.M.P. van der Aalst: Visualizing Object-Centric Process Mining. ATAED Workshop, CEUR-WS vol. 2847 (2020)

2020

Show all 19 references

[9]

Berti, et al

A. Berti, et al. (2024). OCEL (Object-Centric Event Log) 2.0 Specification. arXiv preprint arXiv:2403.01975. https://doi.org/10.48550/arxiv.2403.01975

2024 doi arXiv
[10]

Berti & W.M.P

A. Berti & W.M.P. van der Aalst: Extracting Multiple Viewpoint Models from Relational Databases. Internationa l Symposium on Data-Driven Process Discovery and Analysis. Cham: Springer International Publishing, 2018

2018
[11]

van Detten, P

J.N. van Detten, P. Schumacher, S.J.J. Leemans: A Framework for Advanced Case Notions in Object-Centric Process Mining. ICPM Workshops, Springer LNBIP vol. 533, pp. 402–414 (2025)

2025
[12]

Esser, D

S. Esser, D. Fahland: Multi-Dimensional Event Data in Graph Databases. J. Data Semantics 10, 109–141 (2021)

2021
[13]

Fahland and M

D. Fahland and M. Montali. What is an Object-Centric Case? An Exploration. Mining a Scientist's Process: Essays Dedicated to Wil van der Aalst on the Occasion of His 60th Birthday. Cham: Springer Nature Switzerland, 2026. 398-425

2026
[14]

Ghahfarokhi, G

A.F. Ghahfarokhi, G. Park, A. Berti, W.M.P. van der Aalst (2021). OCEL: A Standard for Object-Centric Event Logs. In European Conference on Advances in Databases and Information System s (pp. 169-175). Cham: Springer International Publishing

2021
[15]

Khayatbashi, et al

S. Khayatbashi, et al. Enriching object- centric event data with process scopes: A framework for aggregation and analysis. arXiv:2508.18830 (2025). https://doi.org/10.48550/arXiv.2508.18830

2025 doi arXiv
[16]

Kumar, A., P

A. Kumar, A., P. Soffer, and A. Tsoury. Normalizing object-centric process logs by applying database principles. Information Systems 115 (2023): 102196

2023
[17]

Leemans, D

S.J.J. Leemans, D. Fahland & W.M. P. van der Aalst: Discovering Block- Structured Process Models from Event Logs — A Constructive Approach. In International conference on applica tions and theory of Petri nets and concurrency (2013), 311-329. Berlin, Heidelberg: Springer Berli...

2013
[18]

Seidel, et al

A. Seidel, et al. (2026) . Object-centric process management: A research manifesto. Information Systems, 102728. 19. Steinau, S., Andrews, K., and Reichert, M. Coordinating large distributed relational process structures. Software and Systems Modeling (2020): 1-33

2026
[20]

De Weerdt, De Backer, M., Vanthienen, J

J. De Weerdt, De Backer, M., Vanthienen, J. & Baesens, B. (2012). A multi- dimensional quality assessment of state- of-the-art process di scovery algorithms using real-life event logs. Information systems, 37(7), 654-676

2012

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.

[1] [8]

Adams, D

J.N. Adams, D. Schuster, S. Schmitz, G. Schuh, W.M.P. van der Aalst (2022). Defining cases and variants for object-centric event data. 2022 4th International Conference on Process Mining (ICPM). IEEE, 2022

2022

[2] [1]

van der Aalst: Process Mining: Data Science in Action

W.M.P. van der Aalst: Process Mining: Data Science in Action. Springer (2016)

2016

[3] [2]

van der Aalst, G

W.M.P. van der Aalst, G. Li, and M. Montali (2017). Object-centric behavioral constraints. arXiv preprint arXiv:1703.05740

arXiv 2017

[4] [3]

van der Aalst et al.: Process Mining Manifesto

W.M.P. van der Aalst et al.: Process Mining Manifesto. BPM Workshops, Springer LNBIP vol. 99 (2012) 12

2012

[5] [4]

van der Aalst: Object-centric process mining: dealing with divergence and convergence in event data

W.M.P. van der Aalst: Object-centric process mining: dealing with divergence and convergence in event data. International Conference on Software Engineering and Formal Methods. Cham: Springer International Publishing, 2019

2019

[6] [5]

WMP van der Aalst & A. Berti. Discovering Object-centric Petri Nets. Fundamenta Informaticae. 2020;175(1-4):1-40. doi:10.3233/FI-2020-1946

doi:10.3233/fi-2020-1946 2020

[7] [6]

van der Aalst

W.M.P. van der Aalst. Object-centric process mining: unraveling the fabric of real processes. Mathematics, 11.12 (2023), 2691

2023

[8] [7]

Adams, A

J.N. Adams, A. Schuster, W.M.P. van der Aalst: Visualizing Object-Centric Process Mining. ATAED Workshop, CEUR-WS vol. 2847 (2020)

2020