pith. sign in

arxiv: 2606.04350 · v1 · pith:ZNUIJS3Onew · submitted 2026-06-03 · 💻 cs.SE

Towards Process Mining Use Case Map Models with PM4Py-UCM

Daniel Amyot This is my paper

Pith reviewed 2026-06-28 05:41 UTC · model grok-4.3

classification 💻 cs.SE
keywords process mininguse case mapsuser requirements notationevent logsprocess discoveryhierarchical decompositionrequirements engineeringmodel export
0
0 comments X

The pith

An extension to the PM4Py library turns event logs into Use Case Map models for requirements engineering.

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

The paper demonstrates an open-source addition to an existing process mining library that produces Use Case Map models directly from event logs. These maps come from the User Requirements Notation and are intended for early requirements activities that currently rely on other diagram types. The addition includes a full discovery pipeline, ways to break models into nested layers, mappings that assign performers to steps, and an export step that keeps the models intact when moved to a URN editing tool. The same logs can be rendered under different performer views or decomposition choices. If the approach works, process mining data can supply evidence for modeling and analysis steps that use the User Requirements Notation.

Core claim

The paper contributes PM4Py-UCM, an extension that adds a UCM discovery pipeline, hierarchical decomposition strategies producing nested UCM models, configurable performer mappings for UCM and BPMN visualizations, and an exporter to jUCMNav that preserves the mined model under round-trip, thereby making Use Case Map models a first-class output of process discovery from event logs so that mined behavior can be used in URN-based modeling, analysis, and management activities.

What carries the argument

The UCM discovery pipeline that applies hierarchical decomposition and performer mappings to event logs and exports the results while preserving structure.

If this is right

  • Mined process behavior from event logs becomes directly usable in URN-based modeling, analysis, and management activities.
  • Hierarchical decomposition strategies produce nested UCM models from the same logs under different levels of detail.
  • Configurable performer mappings allow the same behavior to be shown with different abstractions in both UCM and BPMN forms.
  • The exporter to jUCMNav enables round-trip use so that mined models can be edited and analyzed in an existing URN environment without structural loss.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same logs could be mined once and then compared across UCM and other notations to see which representation best supports particular analysis tasks.
  • Hierarchical options might let analysts start with a high-level map and expand only the parts that need closer examination.
  • Integration with URN tools could let requirements teams treat process mining output as one more source of input alongside use-case scenarios and goal models.
  • Applying the pipeline to logs from domains with strict regulatory requirements could test whether the resulting maps preserve enough detail for compliance checks.

Load-bearing premise

Behavior extracted from event logs can be rendered as valid and useful Use Case Map models that support URN activities without loss of fidelity or introduction of misleading structure.

What would settle it

An event log for which the generated UCM model, when loaded back into a URN tool or checked against the original traces, fails to represent the observed sequences or assigns incorrect responsibilities.

Figures

Figures reproduced from arXiv: 2606.04350 by Daniel Amyot.

Figure 1
Figure 1. Figure 1: The PM4Py-UCM discovery pipeline. • Sequence (→): Activity A must finish before activity B starts. • Exclusive Choice (×): Either activity A or activity B happens, but not both. • Inclusive Choice (∨): Activity A or activity B happens, or both happen. • Parallel (∧) and Interleaving (o): Activities A and B happen concurrently, or in any order. • Loop (⟲): An activity can be repeated multiple times. • Silen… view at source ↗
Figure 2
Figure 2. Figure 2: Models mined from the issue tracking event log. [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Claims payment: UCM view without decomposition (from within the Web interface). [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Claims payment: UCM model exported by PM4Py-UCM to a .jucm file and opened in jUCMNav, with model metrics computed. Note that all 7 maps are there [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Claims payment: UCM view with decomposition. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png] view at source ↗
read the original abstract

Given the increasing amount of data available in organizational systems, there is an opportunity for early requirements engineering (RE) activities to be better based on evidence than ever before. Process mining (PM) has been used for over two decades to discover and analyze as-is process models from event logs extracted from such data, with outputs often in the form of Petri Nets, directly-follows graphs, or BPMN models. This paper aims to make Use Case Map (UCM) models, from ITU-T's User Requirements Notation (URN), a first-class output of process discovery, so that mined behavior can be used in URN-based modeling, analysis, and management activities. This paper contributes and illustrates PM4Py-UCM, an open-source extension to the existing PM4Py Python library. This new tool contributes 1) a UCM discovery pipeline, 2) hierarchical decomposition strategies producing nested UCM models, 3) configurable performer mappings for UCM and BPMN visualizations, and 4) an exporter to a URN tool (jUCMNav) that preserves the mined model under round-trip. Using public and synthetic event logs, the paper showcases how the same behavior is rendered under different performer abstractions and decomposition strategies, and discusses how PM can become a practical instrument for model-driven RE.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The paper presents PM4Py-UCM, an open-source extension to the PM4Py Python library for process mining. It contributes a UCM discovery pipeline that produces Use Case Map models (from ITU-T URN) as a first-class output from event logs, along with hierarchical decomposition strategies for nested models, configurable performer mappings for UCM and BPMN visualizations, and an exporter to jUCMNav that preserves the mined model under round-trip. The work is illustrated via examples on public and synthetic logs showing different performer abstractions and decomposition strategies, with the goal of enabling mined behavior in URN-based requirements engineering activities.

Significance. If the pipeline functions as described and the mappings are faithful, the contribution would be significant for bridging process mining with early requirements engineering by making UCMs directly usable in URN modeling and analysis. The open-source integration with PM4Py and the round-trip exporter are practical strengths that could enable model-driven RE workflows. The absence of quantitative validation, however, substantially reduces the assessed significance of the claims regarding fidelity and utility.

major comments (2)
  1. [Evaluation] Evaluation section: The central claim that the UCM discovery pipeline (with hierarchical decomposition and performer mappings) renders event-log behavior as valid UCMs supporting URN activities without loss of fidelity or misleading structure is not supported by evidence. The manuscript provides only visual examples on public/synthetic logs and claims round-trip preservation, but reports no conformance metrics, trace replay results, fitness/replay values, or scenario comparisons against the input logs. This is load-bearing for the utility assertion.
  2. [Implementation] Implementation and validation: The abstract and contribution list describe the intended features (discovery pipeline, decomposition strategies, mappings, exporter), but the manuscript supplies no details on implementation correctness, error handling, ground-truth validation, or how UCM semantics (responsibilities, OR-forks, paths) are ensured to match log behavior. This undermines assessment of whether the extension actually delivers on the stated claims.
minor comments (1)
  1. [Discovery pipeline] The paper would benefit from explicit discussion of how UCM-specific constructs (e.g., responsibilities on paths) are derived from standard PM outputs like directly-follows graphs or Petri nets.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback on our manuscript. We address the two major comments point by point below. The paper presents a tool extension with illustrative examples rather than a full empirical evaluation study; we are prepared to revise for clarity and added detail where this strengthens the contribution without altering its scope.

read point-by-point responses

  1. Referee: [Evaluation] Evaluation section: The central claim that the UCM discovery pipeline (with hierarchical decomposition and performer mappings) renders event-log behavior as valid UCMs supporting URN activities without loss of fidelity or misleading structure is not supported by evidence. The manuscript provides only visual examples on public/synthetic logs and claims round-trip preservation, but reports no conformance metrics, trace replay results, fitness/replay values, or scenario comparisons against the input logs. This is load-bearing for the utility assertion.

    Authors: The manuscript does not make an explicit quantitative claim of 'no loss of fidelity'; it illustrates the pipeline outputs via examples and states that the exporter preserves the mined model under round-trip. No conformance metrics, fitness values, or replay results are reported because the work is positioned as a tool contribution demonstrating integration and abstraction options, not as an evaluation of discovery accuracy. We agree this leaves the utility claims less substantiated than they could be. We will revise the evaluation section to include basic PM4Py conformance checks (fitness and precision) on the public logs used in the examples and to clarify the scope of the claims. revision: yes

  2. Referee: [Implementation] Implementation and validation: The abstract and contribution list describe the intended features (discovery pipeline, decomposition strategies, mappings, exporter), but the manuscript supplies no details on implementation correctness, error handling, ground-truth validation, or how UCM semantics (responsibilities, OR-forks, paths) are ensured to match log behavior. This undermines assessment of whether the extension actually delivers on the stated claims.

    Authors: The manuscript describes the high-level pipeline and features, with the open-source code serving as the reference implementation. Specific details on error handling, ground-truth validation procedures, and the exact rules mapping log behavior to UCM elements (e.g., responsibilities, OR-forks) are not provided in the text. The round-trip exporter is presented as one form of preservation check. We will add a short implementation subsection or appendix outlining the core mapping rules from directly-follows relations to UCM paths and responsibilities, along with notes on how the hierarchical decomposition is realized. revision: yes

Circularity Check

0 steps flagged

Tool implementation paper with no derivations or fitted quantities

full rationale

The paper describes the design and implementation of an open-source PM4Py extension (UCM discovery pipeline, decomposition strategies, performer mappings, jUCMNav exporter). No equations, parameter fitting, predictions, or uniqueness theorems appear. The central claim is the existence and round-trip functionality of the tool itself, demonstrated via examples on public/synthetic logs. No load-bearing step reduces to a self-citation chain or input by construction; the work is self-contained as software contribution.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Tool contribution paper. No free parameters, mathematical axioms, or invented entities are introduced; the work rests on the existing PM4Py library and standard process mining assumptions.

pith-pipeline@v0.9.1-grok · 5754 in / 1185 out tokens · 11243 ms · 2026-06-28T05:41:38.060381+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

30 extracted references · 21 canonical work pages

  1. [1]

    van der Aalst, Data Science in Action

    W. van der Aalst, Data Science in Action . Springer, 2016, pp. 3–23, doi: 10.1007/978-3-662-49851-4_1

    work page doi:10.1007/978-3-662-49851-4_1 2016

  2. [2]

    ISO/IEC 15909-1:2019 – Systems and software engineering – High-level Petri nets – Part 1: Concepts, definitions and graphical notation,

    ISO, “ISO/IEC 15909-1:2019 – Systems and software engineering – High-level Petri nets – Part 1: Concepts, definitions and graphical notation,” 2019. [Online]. Available: https://www.iso.org/obp/ui/#iso: std:iso-iec:15909:-1:en

    2019

  3. [3]

    Business Process Model and Notation (BPMN), version 2.0.2,

    OMG, “Business Process Model and Notation (BPMN), version 2.0.2,”

  4. [4]

    Available: https://www.omg.org/spec/BPMN/2.0.2

    [Online]. Available: https://www.omg.org/spec/BPMN/2.0.2

  5. [5]

    PM2: a process mining project methodology,

    M. L. van Eck, X. Lu, S. J. J. Leemans, and W. M. P. van der Aalst, “PM2: a process mining project methodology,” in Advanced Information Systems Engineering, CAiSE 2015 . Springer, 2015, pp. 297–313, doi: 10.1007/978-3-319-19069-3_19

    work page doi:10.1007/978-3-319-19069-3_19 2015

  6. [6]

    A systematic literature review of studies comparing process mining tools,

    C. A. Kesici, N. Ozkan, S. Ta¸ skesenlioglu, and T. G. Erdogan, “A systematic literature review of studies comparing process mining tools,” International Journal of Information Technology and Computer Science, vol. 14, no. 5, pp. 1–14, 2022, doi: 10.5815/ijitcs.2022.05.01

    work page doi:10.5815/ijitcs.2022.05.01 2022

  7. [7]

    PM4Py: A process min- ing library for Python,

    A. Berti, S. van Zelst, and D. Schuster, “PM4Py: A process min- ing library for Python,” Software Impacts , vol. 17, 2023, doi: 10.1016/j.simpa.2023.100556

    work page doi:10.1016/j.simpa.2023.100556 2023

  8. [8]

    Data-driven requirements elicitation: A systematic literature review,

    S. Lim, A. Henriksson, and J. Zdravkovic, “Data-driven requirements elicitation: A systematic literature review,” SN Compututer Science , vol. 2, 2021, doi: 10.1007/s42979-020-00416-4

    work page doi:10.1007/s42979-020-00416-4 2021

  9. [9]

    Discovering requirements through goal-driven pro- cess mining,

    J. D ˛ abrowski, F. M. Kifetew, D. Muñante, E. Letier, A. Siena, and A. Susi, “Discovering requirements through goal-driven pro- cess mining,” in 2017 IEEE 25th International Requirements En- gineering Conference Workshops (REW) , 2017, pp. 199–203, doi: 10.1109/REW.2017.61

    work page doi:10.1109/rew.2017.61 2017

  10. [10]

    What requirements engineering can learn from process mining,

    M. Ghasemi, “What requirements engineering can learn from process mining,” in 2018 1st International Workshop on Learning from other Disciplines for Requirements Engineering (D4RE) , 2018, pp. 8–11, doi: 10.1109/D4RE.2018.00008

    work page doi:10.1109/d4re.2018.00008 2018

  11. [11]

    A requirement-driven method for process mining based on model-driven engineering,

    S. I. Bouhidel, M. M. Bouhamed, G. Diaz, and N. Belala, “A requirement-driven method for process mining based on model-driven engineering,” Computer Standards & Interfaces , vol. 97, p. 104108, 2026, doi: 10.1016/j.csi.2025.104108

    work page doi:10.1016/j.csi.2025.104108 2026

  12. [12]

    Recommendation Z.151 (10/2018): User requirements notation (URN) — language definition,

    ITU-T, “Recommendation Z.151 (10/2018): User requirements notation (URN) — language definition,” International Telecommunication Union, Tech. Rep., 2018. [Online]. Available: https://www.itu.int/rec/T-REC-Z. 151-201810-I/en

    2018

  13. [13]

    Use case maps as architectural entities for complex systems,

    R. J. A. Buhr, “Use case maps as architectural entities for complex systems,” IEEE Transactions on Software Engineering , vol. 24, no. 12, pp. 1131–1155, 1998, doi: 10.1109/32.738343

    work page doi:10.1109/32.738343 1998

  14. [14]

    Combining goal modelling with business process modelling: Two decades of expe- rience with the user requirements notation standard,

    D. Amyot, O. Akhigbe, M. Baslyman, S. Ghanavati, M. Ghasemi, J. Hassine, L. Lessard, G. Mussbacher, K. Shen, and E. Yu, “Combining goal modelling with business process modelling: Two decades of expe- rience with the user requirements notation standard,” Enterprise Mod- elling and Information Systems Architectures (EMISAJ)-International Journal of Conceptu...

    work page doi:10.18417/emisa.17.2 2022

  15. [15]

    Towards integrated tool support for the User Requirements Notation,

    J.-F. Roy, J. Kealey, and D. Amyot, “Towards integrated tool support for the User Requirements Notation,” in System Analysis and Modeling: Language Profiles. SAM 2006 , ser. LNCS 4320. Springer, 2006, pp. 198–215, doi: 10.1007/119511

    work page doi:10.1007/119511 2006

  16. [16]

    The ieee xes standard for process mining: Experiences, adoption, and revision [society briefs],

    M. T. Wynn, W. van der Aalst, E. Verbeek, and B. D. Stefano, “The ieee xes standard for process mining: Experiences, adoption, and revision [society briefs],” IEEE Computational Intelligence Magazine , vol. 19, no. 1, pp. 20–23, 2024, doi: 10.1109/MCI.2023.3333141

    work page doi:10.1109/mci.2023.3333141 2024

  17. [17]

    In: European Con- ference on Computer Vision (ECCV) (2024).https://doi.org/10.1007/978- 3- 031- 72667- 5_15,https://www.ecva.net/papers/eccv_2024/papers_ECCV/ papers/01143.pdf

    S. J. J. Leemans, D. Fahland, and W. M. P. van der Aalst, “Discov- ering block-structured process models from event logs - a constructive approach,” in Application and Theory of Petri Nets and Concurrency , ser. LNCS, vol. 7927. Springer, 2013, pp. 311–329, doi: 10.1007/978- 3-642-38697-8_17

    work page doi:10.1007/978- 2013

  18. [18]

    Discovering block-structured process models from event logs containing infrequent behaviour,

    ——, “Discovering block-structured process models from event logs containing infrequent behaviour,” in Business Process Management Workshops, ser. LNBIP, vol. 171. Springer, 2014, pp. 66–78, doi: 10.1007/978-3-319-06257-0_6

    work page doi:10.1007/978-3-319-06257-0_6 2014

  19. [19]

    Consistency analysis for User Requirements Notation models,

    O. Akhigbe, D. Amyot, A. A. Anda, L. Lessard, and D. Xiao, “Consistency analysis for User Requirements Notation models,” in iStar 2016, Ninth International i* Workshop , vol. CEUR-WS V ol-1674, 2016, pp. 43–48. [Online]. Available: https://ceur-ws.org/V ol-1674/ iStar16_pp43-48.pdf

    2016

  20. [20]

    From use case maps to executable test procedures: a scenario-based approach,

    N. Kesserwan, R. Dssouli, J. Bentahar, B. Stepien, and P. Labrèche, “From use case maps to executable test procedures: a scenario-based approach,” Software and Systems Modeling , vol. 18, no. 2, pp. 1543– 1570, 2019, doi: 10.1007/s10270-017-0620-y

    work page doi:10.1007/s10270-017-0620-y 2019

  21. [21]

    From event logs to goals: a systematic literature review of goal-oriented process mining,

    M. Ghasemi and D. Amyot, “From event logs to goals: a systematic literature review of goal-oriented process mining,” Requirements En- gineering, vol. 25, no. 1, pp. 67–93, 2020, doi: 10.1007/s00766-018- 00308-3

    work page doi:10.1007/s00766-018- 2020

  22. [22]

    Goal-oriented process mining: A scalability experiment,

    M. Ghasemi, D. Amyot, and W. Van Woensel, “Goal-oriented process mining: A scalability experiment,” in 2025 IEEE 33rd International Requirements Engineering Conference Workshops (REW) , 2025, pp. 304–313, doi: 10.1109/REW66121.2025.00046

    work page doi:10.1109/rew66121.2025.00046 2025

  23. [23]

    A semi- automated approach for generating natural language requirements doc- uments based on business process models,

    B. Aysolmaz, H. Leopold, H. A. Reijers, and O. Demirörs, “A semi- automated approach for generating natural language requirements doc- uments based on business process models,” Information and Software Technology, vol. 93, pp. 14–29, 2018, doi: 10.1016/j.infsof.2017.08.009

    work page doi:10.1016/j.infsof.2017.08.009 2018

  24. [24]

    Secure two- party quantum evaluation of unitaries against specious adversaries,

    M. Song, C. W. Günther, and W. M. P. van der Aalst, “Trace clustering in process mining,” in Business Process Management Workshops , ser. LNBIP, vol. 17. Springer, 2009, pp. 109–120, doi: 10.1007/978-3-642- 00328-8_11

    work page doi:10.1007/978-3-642- 2009

  25. [25]

    Process discovery using inductive miner and decomposition,

    R. Ghawi, “Process discovery using inductive miner and decomposition,”

  26. [26]

    Available: https://arxiv.org/abs/1610.07989

    [Online]. Available: https://arxiv.org/abs/1610.07989

    Pith/arXiv arXiv

  27. [27]

    Towards comprehensive support for organizational mining,

    M. Song and W. M. P. van der Aalst, “Towards comprehensive support for organizational mining,” Decision Support Systems , vol. 46, no. 1, pp. 300–317, 2008

    2008

  28. [28]

    Discovering social networks from event logs,

    W. M. P. van der Aalst, H. A. Reijers, and M. Song, “Discovering social networks from event logs,” Computer Supported Cooperative Work (CSCW), vol. 14, no. 6, pp. 549–593, 2005

    2005

  29. [29]

    Business process management with the user require- ments notation,

    A. Pourshahid, D. Amyot, L. Peyton, S. Ghanavati, P. Chen, M. Weiss, and A. J. Forster, “Business process management with the user require- ments notation,” Electronic Commerce Research, vol. 9, no. 4, pp. 269– 316, 2009, doi: 10.1007/s10660-009-9039-z

    work page doi:10.1007/s10660-009-9039-z 2009

  30. [30]

    Split miner: automated discovery of accurate and simple business process models from event logs,

    A. Augusto, R. Conforti, M. Dumas, M. La Rosa, and A. Polyvyanyy, “Split miner: automated discovery of accurate and simple business process models from event logs,” Knowledge and Information Systems , vol. 59, no. 2, pp. 251–284, May 2019, doi: 10.1007/s10115-018-1214- x

    work page doi:10.1007/s10115-018-1214- 2019