Towards Process Mining Use Case Map Models with PM4Py-UCM
This paper introduces PM4Py-UCM, an open-source extension to the PM4Py library that enables the discovery of hierarchical Use Case Map (UCM) models from event logs, thereby bridging process mining with early requirements engineering for evidence-based model-driven development.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you run a busy restaurant. You have a massive digital logbook recording every single order, who cooked it, how long it took, and who served it. For years, you've been able to look at this logbook to see the "as-is" flow of your kitchen: "First the order comes in, then the chef chops, then the grill cooks." This is called Process Mining. It's like a detective that looks at the data to draw a map of how things actually happen, rather than how you think they happen.
Usually, these detectives draw maps using standard symbols like BPMN (a flowchart style) or Petri Nets (a mathematical style). But what if you wanted to draw that map using a different language—one that is specifically designed for planning and requirements? A language that not only shows the steps but also clearly answers: "Who is responsible for this step?" and "How does this big task break down into smaller sub-tasks?"
This paper introduces a new tool called PM4Py-UCM that does exactly that. It takes the raw data from your event logs and translates it into Use Case Maps (UCM), a specialized notation used by engineers to design systems before they are built.
Here is a breakdown of what the paper does, using simple analogies:
1. The Translator (The Discovery Pipeline)
Think of the existing process mining tools as a translator that speaks "Data" and "Flowcharts." This new tool, PM4Py-UCM, adds a new language to that translator: UCM.
- How it works: It takes the raw event log (the data) and uses a smart algorithm (called the "inductive miner") to build a "process tree." It then converts that tree into a UCM map.
- The Result: Instead of just seeing a list of tasks, you get a visual map that looks like a roadmap, showing the journey from start to finish.
2. The Matryoshka Dolls (Hierarchical Decomposition)
Imagine you have a giant, messy map of a city. It's so detailed it's impossible to read. You need to zoom out to see the main highways, then zoom in to see the neighborhood streets.
- The Problem: Process logs can be huge. A single map might have 88 steps, which is too cluttered to understand.
- The Solution: The tool automatically breaks the big map into smaller, nested maps (like Russian nesting dolls).
- The "Root" Map: Shows the main phases (e.g., "Receive Order," "Cook," "Serve").
- The "Plug-in" Maps: When you click on a phase, it opens a new, simpler map showing the specific steps inside that phase.
- Why it matters: This helps engineers manage complexity. You can choose to make the maps "aggressive" (breaking them into tiny pieces) or "loose" (keeping them bigger), depending on how much detail you need.
3. The "Who" on the Map (Performer Mappings)
In a standard flowchart, you might see a box that says "Check Inventory." But who actually does it? The tool adds a layer of "Who."
- The Magic: It looks at the data to see who performed the actions. Did "Alice" do it 5 times? Did "Bob" do it 3 times?
- The Output: The tool draws the map with "Components" (like colored boxes representing people, roles, or systems) attached to the steps.
- Analogy: It's like a theater playbill that not only shows the plot but also lists which actor is playing which role in every scene.
- Flexibility: You can choose to group by "Role" (e.g., "The Triage Team") or by "Individual" (e.g., "Tina Triager"). This helps answer the question: "Who does what, and when?"
4. The Two-Way Street (Round-Trip Engineering)
Usually, when you convert a file from one format to another, you lose information. It's like translating a book from English to French and then back to English; the story often gets garbled.
- The Innovation: This tool allows for Round-Trip Engineering.
- You can take a data log turn it into a UCM map export it to a professional tool called jUCMNav (where experts can edit it, add goals, or check for errors).
- Then, you can take that edited map and import it back into the tool to see the changes or visualize it differently.
- Why it matters: It ensures that the data-driven discovery and the human-designed requirements stay connected. You don't lose the "truth" of the data when you start designing the future system.
What the Paper Actually Claims (and what it doesn't)
- It DOES claim: It successfully built a tool that turns raw data logs into UCM maps, breaks them down into manageable chunks, assigns "who" does "what," and allows you to edit them in a professional environment and bring them back.
- It DOES claim: It tested this on two examples: a synthetic "Issue Tracking" log (like a bug report system) and a real-world "Claims Payment" log.
- It DOES NOT claim: It is a perfect solution for every business. The author admits the tool has limitations:
- It currently assumes processes are "well-behaved" (neatly nested), which might not be true for chaotic real-world processes.
- Deciding how to group "Who" does "What" is still a bit of a guess (heuristic) and needs more fine-tuning.
- It doesn't yet handle every tiny detail of the UCM language (like timers or failure points).
In Summary:
This paper presents a bridge between data science (Process Mining) and system design (Requirements Engineering). It gives engineers a way to say, "Let's look at the data to see how our system actually works, and automatically draw a blueprint (UCM) that tells us who is responsible for every step, so we can design a better system for the future."
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.