Potentially, CTL1 formulas can be verified using ILP — and formulas using only possibility or necessity operators can be verified already. So go read the paper and stay tuned to Sophie’s future research!.

While ILP is still NP-hard, powerful tools and heuristics exist, making the computation feasible. With small adaptations, not only reachability but also property verification can be reduced to an ILP problem.

SCCs in a state machine are partially ordered and can only get tokens from their predecessors, so one must make sure one token is not used multiple times if the backward cones of different SCCs overlap. This, in turn, can be solved by integer linear programming (ILP).

This allows to check reachability without exploding the state space. Moreover, as any marking is reachable within an SCC given the required number of tokens (by definition), reachability checking can be reduced to checking if such number of tokens can be provided to the SCC.

State Machines are a particular class of Petri Nets, where each transition can only have one place in its pre- and post-sets and arc weights are always 1. Thanks to this, they can be split into strongly connected components (SCCs), which are then connected by link transitions.

Highlight of the day at the Algorithms and Tools for Petri nets (AWPN) workshop @icpm_conf: paper “State Machines (In Modular Petri Nets)” by Sophie Wallner. Check it out at:

While I do find this work interesting and valuable, I must say that I would not properly understand the paper if I didn’t see the presentation, so I encourage the authors to also make the slides publicly available. The others, don’t miss out the insights and go read the paper!.

In the evaluation, the authors show that all of these patterns are present in real-life event log, and the waiting time (and thus performance) can vary greatly depending on the pattern of actor’s behavior.

The patterns basically arise from answering questions:.1. Did the actor continue working on the next task in a case or did he hand it over?.2. During this hand over, did the actor work on other cases?.3. Which case did the actor prioritize if multiple cases had enabled tasks?

The authors utilize Event Knowledge Graphs to track how actors perform tasks over multiple cases. Based on this, they identify 5 behavior patterns, which they then can separately project on a DFG to separately assess the impact of each pattern on process performance.

Performance analysis is one of the cornerstones of process mining. In particular, waiting times are a prominent analysis target. While existing approaches mostly look for explanations for waiting times in control-flow perspective, the real cause may lie in the actors’ behavior.

Highlight of the day @icpm_conf: paper “Decomposing Process Performance based on Actor Behavior” by @Eva_Klijn, Irina Tentina, @dfahland & @fmannhardt. Check it out at:

All in all, I enjoy watching simulation techniques getting more and more sophisticated. If you like this too, check out the implementation at and and go read the paper!.

In my opinion, it would be beneficial to clearly separate discovery and simulation with such approach. One can just discover, say, Data Petri Nets, and on the other side, these DPNs can be used as input model for the simulation. (I would be actually curious to implement this).

Common critique to log-based simulations in general, as also brought up by @uartem, is “why discover rules and then simulate an event log when you already have an event log?”, and it’s difficult to argue, although such simulations do enable very realistic what-if analysis.

Not surprisingly, they could discover attribute types (EQ1) with up to 95% accuracy and update rules (EQ2) with up to 90% accuracy. Data-aware simulation outperforms the data-unaware in 65-95% of cases in artificial scenarios and in 100% cases in real-life event log-based ones.

For the evaluation, the authors tested how well attribute types (EQ1) and update rules (EQ2) are discovered from event logs and if discovered data-aware branching conditions improve simulations compared to probabilistic approaches (EQ3). Evaluation setup:

To discover branching conditions, the authors propose a hybrid approach: it learns decision trees based on data attributes but has the fallback option to frequency-based probabilities if the former approach does not yield meaningful result.

Distinguishing between global and event attributes is trickier, since same sequence of attribute values can result both from global or event-level updates. The authors guess the type of the attribute by evaluating it as both types and measuring which type fits better.

The idea is then to discover and use generators for independent attributes and update rules for dependent ones. For case attributes one can simply employ generators as they are independent, local to the case and static.