Class Of High-level Petri Nets Research Articles

Verification of Unary Communicating Datalog Programs

We study verification of reachability properties over Communicating Datalog Programs (CDPs), which are networks of relational nodes connected through unordered channels and running Datalog-like computations. Each node manipulates a local state database (DB), depending on incoming messages and additional input DBs from external services. Decidability of verification for CDPs has so far been established only under boundedness assumptions on the state and channel sizes, showing at the same time undecidability of reachability for unbounded states with only two unary relations or unbounded channels with a single binary relation. The goal of this paper is to study the open case of CDPs with bounded states and unbounded channels, under the assumption that channels carry unary relations only. We discuss the significance of the resulting model and prove the decidability of verification of variants of reachability, captured in fragments of first-order CTL. We do so through a novel reduction to coverability problems in a class of high-level Petri Nets that manipulate unordered data identifiers. We study the tightness of our results, showing that minor generalizations of the considered reachability properties yield undecidability of verification, both for CDPs and the corresponding Petri Net model.

A Method to Analyze Predicate Transition Nets Using SPIN Model Checker

High-level Petri nets (HLPNs) are a formal method for studying concurrent and distributed systems and have been widely used in many application domains. However, their strong expressive power hinders their analyzability. In this paper, we present a new transformational analysis method for analyzing a special class of HLPNs — predicate transition (PrT) nets. This method extends and improves our prior results by covering more PrT net features including full first-order logic formulas and exploring additional alternative translation schemes. This new analysis method is supported by a tool chain — front-end PIPE[Formula: see text] for creating and simulating PrT nets and back-end SPIN for model checking safety and liveness properties. We have applied this method to two benchmark systems used in annual Petri net model checking contest 2015. We discuss several properties and show the detailed model checking results in one system.

Automatic execution of business process models: Exploiting the benefits of Model-driven Engineering approaches

The business goals of an enterprise process are traced to business process models with the aim of being carried out during the execution stage. The automatic translation from these models to fully executable code which can be simulated and round-trip engineered is still an open challenge in the Business Process Management field. Model-driven Engineering has proposed a set of methodologies with which to solve the existing gap between business analysts and software developers, but the expected results have not as yet been achieved. In this paper, a new approach to solve this challenge is proposed. This approach is based on the integration of SOD-M, a model-driven method for the development of service-oriented systems, and DENEB, a platform for the development and execution of flexible business processes. SOD-M provides business analysts with a methodology that can be used to transform their business goals into composition service models, a type of model that represents business processes. The use of the Eclipse Modelling Framework and the ATLAS Transformation Language allows this model to be automatically transformed into a DENEB workflow model, resulting in a business process that is coded by a class of high-level Petri-nets and is directly executable in DENEB. The application of the proposal presented herein is illustrated by means of a real system related to the management of medical images.

Performance evaluation of Fractal component-based systems

Component-based system development is now a well accepted design approach in software engineering. Numerous component models have been proposed, and for most of them, specific software tools allow building component-based systems (CBS). Although these tools perform several checks on the built system, few of them provide formal verification of behavioural properties nor performance evaluation of the resulting system. In this context, we have developed a general method associating to a CBS, a formal model, based on stochastic well formed nets, a class of high-level Petri nets, allowing qualitative behavioural analysis together with performance evaluation of this CBS. The definition of the model heavily depends on the (run time) component model used to describe the CBS. In this paper, we instantiate our method to Fractal CBS and its reference Java implementation Julia. The method starts from the Fractal architectural description of a system and defines rules to systematically generate element models of the CBS and their interactions. We then apply a structured method for both qualitative and performance analysis, taking into account the given implementation of the Fractal model. The main interest of our method is to take advantage of the compositional definition of such systems to carry out an efficient analysis. The paper concentrates on performance evaluation and presents our method step by step with an illustrative example.

Parametric fault tree for the dependability analysis of redundant systems and its high-level petri net semantics

In order to cope efficiently with the dependability analysis of redundant systems with replicated units, a new, more compact fault-tree formalism, called Parametric Fault Tree (PFT), is defined. In a PFT formalism, replicated units are folded and indexed so that only one representative of the similar replicas is included in the model. From the PFT, a list of parametric cut sets can be derived, where only the relevant patterns leading to the system failure are evidenced regardless of the actual identity of the component in the cut set. The paper provides an algorithm to convert a PFT into a class of High-Level Petri Nets, called SWN. The purpose of this conversion is twofold: to exploit the modeling power and flexibility of the SWN formalism, allowing the analyst to include statistical dependencies that could not have been accommodated into the corresponding PFT and to exploit the capability of the SWN formalism to generate a lumped Markov chain, thus alleviating the state explosion problem. The search for the minimal cut sets (qualitative analysis) can be often performed by a structural T-invariant analysis on the generated SWN. The advantages that can be obtained from the translation of a PFT into a SWN are investigated considering a fault-tolerant multiprocessor system example.

High-level Petri net model of logic program with negation

The formalism of nonmonotonic reasoning has been integrated into logic programming to define semantics for logic program with negation. Because a Petri net provides a uniform model for both the logic of knowledge and the control of inference, the class of high-level Petri nets called predicate/transition nets (PrT-nets) has been employed to study production rule based expert systems and Horn clause logic programs. We show that a PrT-net can implement the nonmonotonicity associated with a logic program with negation as well as the monotonicity of Horn clause logic program. In particular, we define a semantics for a normal logic program and implement it with PrT-net. We demonstrate that in the presence of inconsistency in a normal logic program, the semantics still works well by deducing meaningful answers. The variations and potential applications of the PrT-net are also addressed. >

High-Level Timed Petri Nets as a kernel for executable specifications

One of the goals of the IPTES environment is to provide a highly usable and formally based specification support environment for real-time applications. Therefore the environment is built upon a formal language that provides a sound, and mathematically well-defined kernel for IPTES. The language provides a means for formulating unambiguous specifications that can be formally verified at any stage of the project. The ability of verifying the specifications from the early stages of the project is very important for revealing errors when their correction can be done at a much lower cost compared with the cost of removing the same errors in later phases. The formal kernel of IPTES is a class of high-level Petri nets, called HLTPNs (High-Level Timed Petri Nets), that allow specifications to be executed, simulated, tested and formally proved. HLTPNs come in two forms: the internal form (HLTPN i ) and the abstract form (HLTPN a ).HLTPN i may be viewed as the machine language of the abstract machine underlying the IPTES environment.HLTPN a provides a higher-level intermediate notation that allows to deal explicitly with aspects related to scheduling of the modeled system.

An object-oriented approach to High-Level Petri Nets

This paper introduces a class of High-Level Petri Nets, called τ-nets, used for the analysis, description, and sub-optimal solution of a general class of problems of process scheduling. τ-nets include timed transitions, a type-checking mechanism, and the definition of taxonomic hierarchies of token types. Objects are typed, including transitions, places, tokens, and the (sub)nets that can be built combining those elements. Furthermore, transitions and tokens belong to two disjoint hierarchies of types supporting a single inheritance mechanism. A class of problems in the FMS area is taken as a reference scenario in the paper. The approach described in this paper is at the basis of a joint project with industrial partners for the development of a CASE tool for the simulation of blast furnaces.