Process mining is the discipline of reconstructing business processes from the digital footprints left in information systems. Every event log must record at least three things: a case identifier that ties events to a single process instance, a timestamp, and an activity label naming the step that occurred. Those activity labels are the backbone of nearly every process mining technique, which makes them a tempting target for anyone asking the classic data science question: how much does garbage in really cost? The researchers framed their work around a simple research question: how do errors on activity labels affect the performance of discovery, conformance checking, and predictive monitoring?

To answer it, the team leaned on a well-established taxonomy of event log imperfection patterns developed by Suriadi and colleagues, focusing on the four that corrupt categorical labels. Distorted labels arise from typos, simulated in the experiments through five operations such as deleting a character, inserting a random one, swapping two characters, substituting a neighboring keyboard key, or flipping case. Polluted labels occur when extra information, such as a resource identifier or a random string, gets glued onto the activity name. Homonymous labels use one name for several genuinely different steps, while synonymous labels describe the same step with different names, a common artifact of merging logs from multiple systems. Using scripts built on the FLAWD language, the researchers injected each error type separately into clean logs at controlled error ratios, from as low as 2 percent of events up to 50 percent for the prediction experiments.

The experimental design cleverly mirrors real-world scenarios. For process discovery, models were built from dirty logs and then tested against clean logs, simulating a hospital that mines a process from error-prone records at one site and applies the resulting model at another site with clean data. For conformance checking, the direction was reversed: models discovered from clean logs were used to replay dirty logs, reflecting organizations that hold a trusted reference model and audit live, imperfect data. For predictive monitoring, long short-term memory neural networks with two layers of 128 nodes were trained on noisy logs and evaluated on clean test data across three tasks: next activity prediction, outcome prediction, and remaining time prediction. The experiments drew on widely used real-life logs from the Business Process Intelligence Challenges of 2011 and 2015, two synthetic datasets that allowed controlled injection of homonyms and synonyms, and a real log from the Italian judicial system.

The starkest result came from process discovery. Fitness, which measures how well a discovered model can replay the clean log, barely budged, because most traces in a dirty log remain clean. Precision, however, collapsed. Error patterns that inject many new labels, namely random distortions and random pollution, drove precision close to zero with as little as 2 percent of events affected, because the discovery algorithm responds to the flood of novel trace variants by producing wildly permissive, underfitting models. Patterns that introduce only a handful of new labels, such as homonyms and synonyms, were far gentler. The practical implication is uncomfortable: cleaning for discovery must be nearly perfect to help, since even a small residue of random errors can destroy model precision, and analysts rarely know the true error rate in advance.

Conformance checking told a much more forgiving story. When a clean reference model was replayed against dirty logs, fitness declined only modestly, by roughly 10 percent in the worst case at a 10 percent error ratio, while precision stayed essentially constant. In many real settings, the authors argue, such degradation may be negligible for decision-making. This asymmetry carries a clear managerial message: it is far riskier to discover a process model from dirty data than to check dirty data against a trustworthy model. The quality of the reference process model, not the cleanliness of every incoming log, is the true fulcrum of reliable process mining.

Predictive process monitoring showed the sharpest differentiation among tasks. Next activity prediction, a multi-class classification problem in which label errors directly corrupt the target classes, suffered massive degradation that scaled with the number of new labels each error pattern introduced. Random pollution was worst, typos came next, and systematic pollution was milder, with performance at a 30 percent error ratio falling to roughly 30 percent of the clean-data baseline. Outcome prediction and remaining time prediction, by contrast, proved remarkably robust, with errors in mean absolute error generally staying within 10 percent of baseline. The researchers attribute this to the models leaning on numerical temporal features, such as time since case start and time since the previous event, rather than the exact wording of activity labels. In a striking twist under mixed error conditions, the LSTM networks eventually learned to discount the noisy categorical features entirely and rely on the unpolluted time series, stabilizing their predictions.

A real-world case study in the Italian civil judicial system grounded these findings outside the laboratory. The telematic case management system SICID defines more than 1,400 event types whose abstract and textual descriptions frequently diverge, creating naturally polluted and ambiguous labels. Training a remaining time predictor on 24,465 finished cases yielded a mean absolute error of 212 days with standardized clean codes versus 269 days with polluted labels, a difference of nearly two months in predicting trial durations. For a justice system under constitutional pressure to deliver timely hearings, that gap is not an academic footnote; it directly affects resource planning and the fairness of proceedings.

Perhaps the most counter-intuitive guidance from the study concerns cleaning priorities. Because errors that multiply the number of distinct activity labels, especially random typos and random pollution, cause the most damage, the authors recommend prioritizing cheap, automated fixes for random errors over expensive expert-driven efforts to resolve synonyms and homonyms, which introduce few new labels and correspondingly little harm. Techniques borrowed from tabular data cleaning, such as the Sorted Neighborhood deduplication method, edit distance metrics, word embeddings, transformer-based semantic similarity, and domain ontologies, can all be deployed to detect and repair label errors. Conformance checking itself can even serve as a diagnostic, with alignment discrepancies pinpointing which labels need targeted repair.

The study is candid about its limits: it relies on the Heuristic Miner discovery algorithm and LSTM-based predictors, restricts itself to imperative process models, and uses random uniform error injection that may not capture every real-world failure mode. Yet the authors see no strong theoretical reason why other algorithms would behave fundamentally differently. What emerges is a practical knowledge base for anyone designing process mining pipelines: know your downstream task before you clean, spend your data quality budget where new labels multiply, and treat a trusted process model as your best defense against dirty data. In an era when organizations increasingly hand their operations to data-driven analysis, this work is a reminder that the humble activity label, the word naming each step of a process, can be the difference between insight and illusion.

Subject of Research: The impact of activity label errors in event logs on process mining tasks such as process discovery, conformance checking, and predictive process monitoring

Article Title: On the impact of low-quality activity labels on data-driven process analytics

Article References: Comuzzi, M., Kim, S., Ko, J., Cappiello, C., Salamov, M., & Pernici, B. (2026). On the impact of low-quality activity labels on data-driven process analytics. International Journal of Data Science and Analytics, 22(1), Article 340. https://doi.org/10.1007/s41060-026-01334-z

Image Credits: AI Generated

DOI: 10.1007/s41060-026-01334-z

Keywords: process mining, event logs, data quality, activity labels, process discovery, conformance checking, predictive process monitoring, data cleaning, LSTM, machine learning, imperfection patterns, business process management

The work builds on Object-Centric Event Data, a modern way of recording process behavior that captures how a single event involves multiple objects at once. In a hospital, the event of registering a test may simultaneously concern a patient, a caregiver, and a specific diagnostic procedure such as a 12-lead ECG or a fasting blood glucose test. The widely adopted Object-Centric Event Log standard, now in its 2.0 specification, stores these many-to-many relationships between events and objects, along with object-to-object relations and attributes that can change over time. This richness is precisely what allows object-centric process mining to discover far more realistic models than the traditional single-case logs that dominated the field for two decades. But it also creates a new challenge: the algorithms that transform these logs into visual models, such as Object-Centric Directly-Follows Graphs, operate at a fixed level of abstraction, deriving process logic from the sequence of event types associated with each object type over time.

The consequence of that fixed abstraction is illustrated by the researchers’ hospital running example. When a caregiver orders an ECG test, registers the result, and then orders a blood test as a standard follow-up procedure, the log faithfully records each concrete action. Yet because all tests share the same generic event types and the same Test object type, the discovered model shows only a flat loop of ordering and registering tests. The clinically meaningful pattern, in which a concerning ECG result triggers a blood test, remains invisible. The authors’ solution borrows a page from the world of Online Analytical Processing, the multidimensional analysis paradigm behind business intelligence tools like Excel pivot tables and data cubes. Van der Aalst proposed the idea of process cubes with slice, dice, drill-down and roll-up operations as early as 2013, but those early implementations predated object-centric process mining and could not handle events tied to multiple objects. The new work brings the OLAP vision fully into the object-centric era.

Four operations form the core of the contribution. Drill-down refines object types by splitting a generic type into variants based on an attribute value, so a Test object type can be decomposed into 12-lead ECG, Monitoring ECG, Fasting Blood Glucose Test and Arterial Blood Gas Test. The operation can be applied recursively and, importantly, comes in a time-aware variant that uses the historical values of object attributes, meaning an object can belong to different drilled-down types at different points in its lifecycle. Roll-up is the inverse: it merges several fine-grained object types into a coarser category, such as grouping the two ECG variants into an ECG Test category that matches how clinicians actually reason. Unfold operates on event types rather than object types, making implicit event-object associations explicit by projecting each event type into a combination of the event type and the object type it concerns, so the generic order test becomes order ECG Test or order Blood Test. Fold collapses those unfolded variants back into their original generic labels.

Each operation is accompanied by a formal algorithm that manipulates the components of the OCEL 2.0 structure, extending sets of object or event types, reassigning the type functions, and updating attribute type mappings while preserving all existing event-to-object and object-to-object relations. The structural connectivity of the log is never broken, which means analysts can chain operations freely: drill down into tests, unfold the ordering and registration events, fold selected variants back together, and roll up categories, all without reloading or reconstructing the data. The authors have implemented everything in an open-source Python library called processmining, installable with a single pip command, and released the running example, case study data and evaluation code on GitHub to support reproducibility.

To demonstrate real-world value, the team applied the approach to four years of educational process data from a Business Process Management course at Stockholm University, extracted from the Moodle learning management system following their OCPM2 methodology. The dataset covered 401 students organized into 91 groups, with between roughly 38,000 and 61,000 events per year and tens of thousands of event-to-object relations. In its raw form, the discovered process model was nearly useless: students and teachers were conflated under a single user object type, all assignments were lumped into one assign type, and no individual task could be distinguished. After drilling down on the user role and assignment name attributes and unfolding the relevant events, the model blossomed into a detailed flow of five clear milestones, revealing exactly which student in each group submitted each lab, how teachers graded individually even for group work, and how many students needed grade updates after failing a first attempt.

The case study also surfaced findings with practical consequences for course design. The final, optional process mining assignment attracted only 13 submissions compared with 23 for an earlier lab, and grading touched just 28 students against 134 for the first milestone. Follow-up investigation showed the optional module was scheduled close to the final exam, leading most students to prioritize exam preparation. More strikingly, the detailed models revealed that resubmission attempts for failed labs were entirely absent from the digital record, indicating those submissions were handled offline, an actionable gap for anyone seeking to improve the educational process. Quantitatively, the team discovered object-centric Petri nets before and after transformation and computed fitness and precision for 71 of the 91 groups, finding significant improvements for most groups after drilling down and unfolding. For the handful of groups with poor fitness, converting the logs into temporal Event Knowledge Graphs exposed the culprit: heavy rolling group membership, with one group losing 11 of its students to other groups during the course, something current object-centric techniques cannot account for because they model object relations as static.

The error analysis added a further layer of insight. Twenty groups defeated the conformance checking library entirely, and ten of those came from 2023, the year the course introduced optional tracks that made the process less structured. Point-biserial correlations showed that model complexity metrics, including the number of places, transitions, arcs, silent transitions, AND-splits and AND-joins, all correlated moderately and significantly with conformance checking failures, with synchronization-heavy parallel constructs exerting the strongest influence while XOR-based choice structures played a secondary role. This points to a broader need for more scalable and robust conformance checking algorithms for object-centric Petri nets, a limitation the authors candidly acknowledge as a threat to validity since the operations themselves applied successfully to all 91 groups.

Scalability was tested on publicly available object-centric event logs derived from the Business Process Intelligence Challenge datasets of 2014, 2016, 2017 and 2019, ranging from about seven hundred thousand to more than seven million events. The researchers drilled down on the most frequent object type using synthetic attributes with between 2 and 10 categories and unfolded all strongly associated event types. The number of categories had little effect on performance; what mattered was log size and connectivity. For the three smaller logs, unfold calls took roughly 1.5 to 3.2 seconds each, while the massive BPIC 2016 log, with its enormous number of event-to-object relations, required around 29 seconds per unfold call and about 60 seconds for drill-down. Crucially, the dominant cost for that log was simply loading it into the PM4Py library, an order of magnitude slower than the operations themselves. This finding underscores why in-place abstraction matters: being able to roll up or fold without reloading makes interactive analysis feasible on industrial-scale data.

The operations have already proven their versatility beyond education, having been applied in the insurance domain, providing a form of methodological triangulation across settings. Because object-centric event data can be transformed bidirectionally between OCEL and temporal Event Knowledge Graphs, the same OLAP operations can be combined with graph queries, centrality measures and community detection, letting analysts exploit the strengths of both representations. The authors frame their contribution as a foundation for more dynamic and detailed process mining methodologies, and they chart clear future directions: scalable conformance checking for object-centric models, better handling of dynamic object-to-object relationships during discovery, and integration of the operations into mainstream process mining tools. For organizations drowning in multi-dimensional event data, the message is simple and compelling: the right insight may already be in your log, waiting at the right level of zoom.

Subject of Research: Granularity-adjusting OLAP operations for object-centric process mining on Object-Centric Event Logs

Article Title: Advancing object-centric process mining with multi-dimensional data operations

Article References: Khayatbashi, S., Miri, N., & Jalali, A. (2026). Advancing object-centric process mining with multi-dimensional data operations. Knowledge and Information Systems, 68(1), Article 275. https://doi.org/10.1007/s10115-026-02904-0

Image Credits: AI Generated

DOI: 10.1007/s10115-026-02904-0

Keywords: object-centric process mining, Object-Centric Event Log, OLAP operations, drill-down, roll-up, process discovery, event knowledge graphs, educational process mining, conformance checking, scalability, OCEL 2.0, business process management