Revealing Inherent Concurrency in Event Data: A Partial Order Approach to Process Discovery

2025-09-18

AI Summary

Traditional process discovery algorithms linearize event sequences, thereby losing concurrency information; existing partial-order-based approaches, in turn, suffer from poor scalability on large-scale event logs. This paper proposes a scalable, partial-order-driven process discovery method: it directly models concurrent behavior based on partial-order relations inherent in event data, avoiding distortion caused by sequence linearization; it introduces a hierarchical aggregation algorithm that abstracts process structure while preserving control-flow semantics—including exclusive choice and loops. To the best of our knowledge, this is the first end-to-end partial-order process mining approach achieving both efficiency and scalability. Experiments on multiple complex real-world logs demonstrate that the method produces fully fitting, structurally compact, and semantically precise process models—significantly enhancing expressive power for concurrency representation and improving computational scalability.

Technology Category

• Data Mining & Knowledge Management: Scalability, Parallel & Distributed Systems
• Search and Optimization: Distributed Search
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Representation, reconstruction, and subgraph or motif discovery in Web-related graphs
• Web Mining and Content Analysis: Topic discovery and tracking
• Semantics and Knowledge: Methods, algorithms and applications for the development of semantic models, knowledge graphs and other forms of structured data models with machine-interpretable semantics

Abstract

Process discovery algorithms traditionally linearize events, failing to capture the inherent concurrency of real-world processes. While some techniques can handle partially ordered data, they often struggle with scalability on large event logs. We introduce a novel, scalable algorithm that directly leverages partial orders in process discovery. Our approach derives partially ordered traces from event data and aggregates them into a sound-by-construction, perfectly fitting process model. Our hierarchical algorithm preserves inherent concurrency while systematically abstracting exclusive choices and loop patterns, enhancing model compactness and precision. We have implemented our technique and demonstrated its applicability on complex real-life event logs. Our work contributes a scalable solution for a more faithful representation of process behavior, especially when concurrency is prevalent in event data.

Problem

• Capturing inherent concurrency in event data
• Addressing scalability issues with large event logs
• Developing faithful process models preserving concurrency

Innovation

• Leverages partial orders for process discovery
• Aggregates traces into sound process model
• Hierarchical algorithm preserves concurrency and abstraction