A theory of implementation and refinement in timed Petri nets

IEEE Transactions on Software Engineering, 1994

The problem of formally analyzing properties of real-time systems is addressed. A method is proposed that allows specifying system properties in the TRIO language (an extension of temporal logic suitable to deal explicitly with the "time" variable and to measure it) and modeling the system as a timed Petri net. It is argued that such an approach is more general than analyzing program properties. The proof method is based on an axiomatization of timed Petri nets in terms of TRIO so that their properties can be derived as suitable theorems in much the same spirit as classical Hoare's method allows proving properties of programs coded in a Pascal-like language. The method is then exemplified through two classical "benchmarks" of the literature on concurrent and real-time systems, namely an elevator system and the dining philosophers problem. A thorough review of the related literature and a comparison thereof with the new method is also provided. Possible alternative methods, theoretical extensions, and practical applications are briefly discussed.

Journal of the Brazilian Society of Mechanical Sciences and Engineering, 2011

Time Petri Net (TPN) models have been widely used to the specification and verification of real-time systems. However, the claim that most of these techniques are useful for realtime system verification can be discussed, based on two assumptions: i) to be suitable for real-time systems verification, a technique must be able to check timing properties, both safe and behavioral, and ii) the underlying algorithm must be efficient enough to be applied to complex systems design. In this paper we will discuss the suitability of commonly accepted verification techniques that use model-checking as a verification framework and TPN as a description model. We present a new algorithmic approach that allows computation of end-to-end time between activities over an abstract state space model. The proposed approach needs to compute the abstract state space only once improving the efficiency of the verification process and turning it suitable for large problems. We also introduce a new sufficient condition for abstract states space to preserve the branching time properties that yields more compact graphs than the condition already used in actual approaches. The approach would fit a design environment also based on Petri Nets called GHENeSys (General Hierarchical Enhanced Petri Nets). The results obtained, using our verification approach are compared with similar available approaches.

Engineering Journal, 2018

The behavioral correctness of real-time software systems relies on both the results of its computation and the clock times when the results are produced. Obviously, formal verification of the safety and correctness of real-time software specification from the very beginning of the software design phase obviously helps us reduce the development efforts. From a practical point of view, the timed Petri net is commonly used to graphically model and illustrate the view of the timed behavior of real-time software systems, which is a good basis for an understanding of a model. However, there is a lack of development process software for the simulation of a timed Petri net. Alternatively, formal verification using the Event-B specification method provides an efficient automatic theorem proving tool which is focused on the development process and provides an efficient verified internal data of software. Unfortunately writing an Event-B specification from scratch is still difficult and a mathematical logic background is needed. In this paper, we propose an automatic transformation of ordinary timed Petri nets into Event-B specifications. The basic notations in the ordinary timed Petri nets are considered and mapped into the code fragments of Event-B. The final resulting Event-B codes are generated in the well-formed format which is required and successfully verified by an Event-B prover called a Rodin tool.

Journal of Control, Automation and Electrical Systems, 2017

Formal verification methods using Time Petri Net have called the attention of researchers and practitioners in real-time systems design during the last two decades. Special attention was dedicated to methods that could be integrated to the design process since the very beginning, that is, in the requirement phase. However, real-time systems requirements are always concerned with quantitative temporal properties, and therefore, a verification technique should give some feedback on target values for these properties. This paper presents an alternative algorithm-based on reachability-to treat the real-time verification of discrete systems. The proposed method is based on an enumerative technique to generate the complete state space that has some advantages-since it has to be done only once-and disadvantages-since the process is combinatorial. However, our proposal leads to better results when compared to other available techniques, especially to complex problems, besides being able to evaluate quantitative and qualitative properties in the same process. Timed Computation Tree Logic is used as specification language, and Timed Transition Graph (TTG) is introduced to represent system functional behavior. A new algorithm is proposed to build a TTG and applied to a case study to illustrates the operation of the proposed algorithm.

Third IEEE International Conference on Software Engineering and Formal Methods (SEFM'05), 2005

Petri nets are a graph-based modelling formalism which has been widely used for the formal specification and analysis of concurrent systems. A common analysis technique is that of state space exploration (or reachability analysis). Here, every possible reachable state of the system is generated and desirable properties are evaluated for each state. This approach has the great advantage of conceptual simplicity, but the great disadvantage of being susceptible to state space explosion, where the number of states is simply too large for exhaustive exploration. Many reduction techniques have been suggested to ameliorate the problem of state space explosion. In the case of timed systems, the state space is infinite, unless analysis is restricted to a bounded time period. In this paper, we present a Petri net formalism based on the notion of relative time (as opposed to the traditional approach of dealing with absolute time). The goal is to derive a finite state space for timed systems which have repeating patterns of behaviour, even though time continues to advance indefinitely.

1993

The IPTES toolset and methodology have been developed for supporting speci cations, design and implementation of real time systems. Such systems are often used in safety critical applications and may thus require intensive testing and analysis before being released for their nal use. The IPTES toolset provides analysis mechanisms based on execution and animation of speci cations. Such capabilities may be enough for extensive analysis of many hard real-time systems. However, in some cases, part of the system may require additional analysis. New techniques for the analysis of temporal properties based on the IPTES formal kernel model (High-Level Timed Petri Nets) have been studied and developed within the IPTES project. This report describes a rst prototype that automatically proofs temporal properties for High-Level Timed Petri Nets. It includes the description of the main design issued, an end-user manual and an experience report that describes the use of the prototype on some initial examples.

Lecture Notes in Computer Science

Time dependant models have been intensively studied for many reasons, among others because of their applications in software verification and due to the development of embedded platforms where reliability and safety depend to a large extent on the time features. Many of the time dependant models were suggested as real-time extensions of several well-known untimed models. The most studied formalisms include Networks of Timed Automata which extend the model of communicating finite-state machines with a finite number of real-valued clocks, and timed extensions of Petri nets where the added time constructs include e.g. time intervals that are assigned to the transitions (Time Petri Nets) or to the arcs (Timed-Arc Petri Nets). In this paper, we shall semiformally introduce these models, discuss their strengths and weaknesses, and provide an overview of the known results about the relationships among the models.

Theory and Practice of Logic Programming, 2006

The theory of Petri Nets provides a general framework to specify the behaviors of real-time reactive systems and Time Petri Nets were introduced to take also temporal specifications into account. We present in this paper a forward zone-based algorithm to compute the state space of a bounded Time Petri Net: the method is different and more efficient than the classical State Class Graph. We prove the algorithm to be exact with respect to the reachability problem. Furthermore, we propose a translation of the computed state space into a Timed Automaton, proved to be timed bisimilar to the original Time Petri Net. As the method produce a single Timed Automaton, syntactical clocks reduction methods (Daws and Yovine for instance) may be applied to produce an automaton with fewer clocks. Then, our method allows to model-check T-TPN by the use of efficient Timed Automata tools.

Lecture Notes in Computer Science, 2001

We set the ground for research on a timed extension of Petri nets where time parameters are associated with tokens and arcs carry constraints that qualify the age of tokens required for enabling. The novelty is that, rather than a single global clock, we use a set of unrelated clocks-possibly one per place-allowing a local timing as well as distributed time synchronisation. We give a formal definition of the model and investigate properties of local versus global timing, including decidability issues and notions of processes of the respective models.