1,629 research outputs found
Learning Hybrid Process Models From Events: Process Discovery Without Faking Confidence
Process discovery techniques return process models that are either formal
(precisely describing the possible behaviors) or informal (merely a "picture"
not allowing for any form of formal reasoning). Formal models are able to
classify traces (i.e., sequences of events) as fitting or non-fitting. Most
process mining approaches described in the literature produce such models. This
is in stark contrast with the over 25 available commercial process mining tools
that only discover informal process models that remain deliberately vague on
the precise set of possible traces. There are two main reasons why vendors
resort to such models: scalability and simplicity. In this paper, we propose to
combine the best of both worlds: discovering hybrid process models that have
formal and informal elements. As a proof of concept we present a discovery
technique based on hybrid Petri nets. These models allow for formal reasoning,
but also reveal information that cannot be captured in mainstream formal
models. A novel discovery algorithm returning hybrid Petri nets has been
implemented in ProM and has been applied to several real-life event logs. The
results clearly demonstrate the advantages of remaining "vague" when there is
not enough "evidence" in the data or standard modeling constructs do not "fit".
Moreover, the approach is scalable enough to be incorporated in
industrial-strength process mining tools.Comment: 25 pages, 12 figure
Discovering duplicate tasks in transition systems for the simplification of process models
This work presents a set of methods to improve the understandability of process models. Traditionally, simplification methods trade off quality metrics, such as fitness or precision. Conversely, the methods proposed in this paper produce simplified models while preserving or even increasing fidelity metrics. The first problem addressed in the
paper is the discovery of duplicate tasks. A new method is proposed that avoids overfitting by working on the transition system generated by the log. The method is able to discover duplicate tasks even in the presence of concurrency and choice. The second problem is the structural simplification of the model by identifying optional and repetitive tasks. The tasks are substituted by annotated events that allow the removal of silent tasks and reduce the complexity of the
model. An important feature of the methods proposed in this paper is that they are independent from the actual miner used for process discovery.Peer ReviewedPostprint (author's final draft
Subtyping for Hierarchical, Reconfigurable Petri Nets
Hierarchical Petri nets allow a more abstract view and reconfigurable Petri
nets model dynamic structural adaptation. In this contribution we present the
combination of reconfigurable Petri nets and hierarchical Petri nets yielding
hierarchical structure for reconfigurable Petri nets. Hierarchies are
established by substituting transitions by subnets. These subnets are
themselves reconfigurable, so they are supplied with their own set of rules.
Moreover, global rules that can be applied in all of the net, are provided
On Negotiation as Concurrency Primitive
We introduce negotiations, a model of concurrency close to Petri nets, with
multiparty negotiation as primitive. We study the problems of soundness of
negotiations and of, given a negotiation with possibly many steps, computing a
summary, i.e., an equivalent one-step negotiation. We provide a complete set of
reduction rules for sound, acyclic, weakly deterministic negotiations and show
that, for deterministic negotiations, the rules compute the summary in
polynomial time
Recent advances in petri nets and concurrency
CEUR Workshop Proceeding
Combining petri nets and uml for model-based software engineering
UML is by far the most widely used modelling language used nowadays in software engineering, due to its large scope and its wide tool support. This software standard offers many diagrams that cover all typical perspectives for describing and modelling the software systems under consideration. Among those diagrams, UML includes diagrams (activity diagram, state machine diagram, use case diagrams, and the interaction diagrams) for describing the behaviour (or functionality) of a software system. Petri nets constitute a well-proven formal modelling language, suitable for describing the behaviour of systems with characteristics like concurrency, distribution, resource sharing, and synchronisation. Thus, one may question why not combining some UML diagrams with Petri nets for effectively supporting the activities of the software engineer. The usage of Petri nets for/in Software Engineering was addressed by several well-known researchers, like, for example, Reisig [6], Pezzè [1], Machado [5], and Kindler [4].
In this invited paper, we discuss some alternatives to introduce Petri nets into a UML-based software development process. In particular, we describe how Coloured Petri Net (CPN) models can be used to describe the set of scenarios associated with a given use case. We describe three different alternatives that can be adopted to achieve that purpose.
The first approach, initially presented in [7], suggests a set of rules that allow software engineers to transform the behaviour described by a UML 2.0 sequence diagram into a CPN model. Sequence diagrams in UML 2.0 are much richer than those in UML 1.x, namely by allowing several traces to be combined in a unique diagram, using high-level operators over interactions. The main purpose of the transformation is to allow the development team to construct animations based on the CPN model that can be shown
to the users or the clients in order to reproduce the expected scenarios and thus validate them. Thus, non-technical stakeholders are able to discuss and validate the captured requirements. The usage of animation is an important topic in this context, since it permits the user to discuss the system behaviour using the problem domain language.
In the second approach, discussed in [3], we assume that developers specify the functionality of the system under consideration with use cases, each of which is described by a set of UML 2.0 sequence diagrams. For each use case, there should exist at least one sequence diagram that represents and describes its main scenario. Other sequence diagrams for the same use case are considered to be variations of the main scenario. The transformation approach allows the development team to interactively play or reproduce any possible run of the given scenarios. In particular, the natural characteristics of the CPN modelling language facilitate the representation of the hierarchy and concurrency constructs of sequence diagrams.
The third alternative, considered in [2], is an improvement with respect to the previous approach and is targeted to reactive systems.We identify and justify two key properties that the CPN model must have, namely: (1) controller-and-environment-partitioned, which means constituting a description of both the controller and the environment, and distinguishing between these two domains and between desired and assumed behaviour; (2) use case-based, which means constructed on the basis of a given use case diagram and reproducing the behaviour described in accompanying scenario descriptions. We have demonstrated how this CPN model is useful for requirements engineering, since it provides a solid basis for addressing behavioural issues early in the development process, for example regarding concurrent execution of use cases and handling of failures
- …