Mathematics and Computer Science

Abstract. Transition priorities can be a useful mechanism when modeling using Petri nets. For example, high-priority transitions can be used to model exception handling and low-priority transitions can be used to model background tasks that should only be executed when no other transition is enabled. Transition priorities can be simulated in Petri nets using, eg, inhibitor arcs, but such constructs tend to unnecessarily clutter models, making it useful to support priorities directly.

Abstract. Semiconductor technology miniaturization allows designers to pack more and more transistors onto a single chip. The resulting System on Chip (SoC) designs are predominant for embedded systems such as mobile devices. Such complex chips are composed of several subsystems called Intellectual Property blocks (IPs) which can be developed by independent partners. Functional verification of large SoC platforms is an increasingly demanding task.

This progress report outlines the work conducted on part A of my PhD study at the Department of Computer Science, University of Aarhus. During Part A of my PhD study, I have conducted work in three areas related to modeling of computer systems. Firstly, I have participated in the design and implementation of a state-space tool, which is intended to be easy to extend. As a part of this, I have participated in developing and testing a concrete way to do state-space analysis.

Abstract. Grading dozens of Petri net models manually is a tedious and error-prone task. In this paper, we present Grade/CPN, a tool supporting the grading of Colored Petri nets modeled in CPN Tools. The tool is extensible, configurable, and can check static and dynamic properties. It automatically handles tedious tasks like checking that good modeling practise is adhered to, and supports tasks that are difficult to automatize, such as checking model legibility.

Automatic code generation based on Coloured Petri Net (CPN) models is challenging because CPNs allow for the construction of abstract models that intermix control flow and data processing, making translation into conventional programming constructs difficult. We introduce Process-Partitioned CPNs (PP-CPNs) which is a subclass of CPNs equipped with an explicit separation of process control flow, message passing, and access to shared and local data.

Abstract. Coloured Petri nets (CP-nets or CPNs) is a useful modeling formalism for formally describing concurrent systems, and CPN Tools provides a mature environment for constructing, simulating, and performing simple analysis of CPN models. Sometimes, this does not suffice, however. For example, if one wishes to extend the analysis capabilities or to integrate CPN models into other programs. In this paper we present two new interfaces which facilitate this.

Abstract. Colored Petri Nets (CPNs) extend the classical Petri net formalism with data, time, and hierarchy. These extensions make it possible to model complex processes as CPNs without being forced to abstract from relevant aspects. Moreover, CPNs are supported by CPN Tools—a powerful toolset that supports the design and analysis of such processes. The expressiveness of the CPN language enables different modeling approaches. Typically, the same process can be modeled in numerous ways.

Model checking is applied for verification of concurrent systems by users having different skills and background. This ranges from researchers with detailed knowledge of the inner workings of the tools to engineers that are mostly interested in applying the technology as a black-box. This paper proposes JoSEL, a graphical language for specification of executable model checking jobs.

Abstract. Declare adheres to the declarative workflow modeling paradigm, where, instead of modeling allowed behavior and explicit choices, users model disallowed behavior. This makes it easier to model loosely structured processes. Without appropriate precautions, however, users are less supported in choosing which actions lead to the desired endresult. The goal of Declare is to ensure flexibility when modeling loosely structured processes and, at the same time, to provide support for decision making during the execution.

Biotechnological improvements over the last decade has made it economically and technologically feasible to collect large DNA sequence data from many closely related species. This enables us to study the detailed evolutionary history of recent speciation and demographics. Sophisticated statistical methods are needed, however, to extract the information that DNA sequences hold, and a limiting factor in this is dealing with the large state space that the ancestry of large DNA sequences spans.

This paper introduces Access/CPN 2.0, which extends Access/CPN with high-level primitives for interacting with coloured Petri net (CPN) models in Java programs. The primitives allow Java programs to monitor and interact with places and transitions during execution, and embed entire programs as subpages of CPN models or embed CPN models as parts of programs. This facilitates building environments for systematic testing of program components using a CPN models.

Both simulation and process mining can be used to analyze operational business processes. Simulation is model-driven and very useful because different scenarios can be explored by changing the model's parameters. Process mining is driven by event data. This allows detailed analysis of the observed behavior showing actual bottlenecks, deviations, and other performance-related problems. Both techniques tend to focus on the control-flow and do not analyze resource behavior in a detailed manner.

To bridge the gap between domain experts and formal methods experts, visualisations of the behaviour of formal models are used to let the domain expert understand and experiment with the formal model. In this paper we provide a definition of visualisations, founded in game-theory, which regards visualisations as transition systems synchronised with formal models.

State space analysis is one of the main approaches to model-based verification of concurrent systems and is one of the most successfully applied analysis methods for Coloured Petri Nets (CP-nets or CPNs)[13, 16, 17]. The basic idea of state space exploration and analysis is to compute all reachable states and state changes of the concurrent system under consideration and represent these as a directed graph.

Abstract. The contribution of this paper is a tutorial in the use of BRITNeY animation tool together with CPN Tools to make different views on Coloured Petri Nets. Examples of such views are messagesequence charts, gantt-charts, or SceneBeans animations showing the state of the model. In this paper we will describe how to generate messagesequence charts from executions of Coloured Petri Nets and how to create SceneBeans animations. Keywords: Model-driven prototyping; visualization; Coloured Petri nets; CPN Tools.

Linear Temporal Logic (LTL) on finite traces has proven to be a good basis for the analysis and enactment of flexible constraint-based business processes. The Declare language and system benefit from this basis. Moreover, LTL-based languages like Declare can also be used for runtime verification. As there are often many interacting constraints, it is important to keep track of individual constraints and combinations of potentially conflicting constraints.

In this paper, we describe the modeling and analysis of a protocol for operational support during workflow enactment. Operational support provides online replies to questions such as “is my execution valid?” and “how do I end the execution in the fastest/cheapest way?”, and may be invoked multiple times for each execution.

We present an industrial project conducted at Ericsson Danmark A/S, Telebit where formal methods in the form of Coloured Petri Nets (CP-nets or CPNs) have been used for the specification of an interoperability protocol for routing packets between fixed core networks and mobile ad-hoc networks.

Declarative workflow languages are easy for humans to understand and use for specifications, but difficult for computers to check for consistency and use for enactment. Therefore, declarative languages need to be translated to something a computer can handle. One approach is to translate the declarative language to linear temporal logic (LTL), which can be translated to finite automata.