State space computation and analysis of Time Petri Nets

Journal of Computational Methods in Sciences and Engineering, 2005

PN (PN) are tools for the analysis and design of concurrent systems. There is a formal theory, which supports PN. An extension of PN is Petri Nets with Clocks (PNwC). PNwC are useful to model systems with temporal requirements via specification of clocks, using temporal invariants for the places and temporal conditions in the transitions. Using invariants in places allows the specifications of hard deadlines constrains (upper bound constrains): when a deadline is reached the progress of time is blocked by the invariant and the action becomes urgent. An algorithm for the analysis of a PNwC has been proposed in [1]. The algorithm is oriented to the verification and correction of errors in the modelling of the time variable. The algorithm generates information about temporal unreachable states and process deadlocks with temporal blocks. Also, it corrects places invariants and transitions conditions. We present here a formalism for PNwC based on Timed Graphs. The analysis algorithm is presented here using the formalism. We show here how Petri Net theory can be joined with Timed Graph theory to construct a formalism, which supports a tool for the analysis of models of concurrent process with real time specification.

Electronic Notes in Theoretical Computer Science, 2005

In this paper, we consider Time Petri Nets (TPN) where time is associated with transitions. We give a formal semantics for TPNs in terms of Timed Transition Systems. Then, we propose a translation from TPNs to Timed Automata (TA) that preserves the behavioral semantics (timed bisimilarity) of the TPNs. For the theory of TPNs this result is two-fold: i) reachability problems and more generally TCTL model-checking are decidable for bounded TPNs; ii) allowing strict time constraints on transitions for TPNs preserves the results described in i). The practical applications of the translation are: i) one can specify a system using both TPNs and Timed Automata and a precise semantics is given to the composition; ii) one can use existing tools for analyzing timed automata (like Kronos, Uppaal or Cmc) to analyze TPNs. In this paper we describe the new feature of the tool Romeo that implements our translation of TPNs in the Uppaal input format. We also report on experiments carried out on various examples and compare the result of our method to state-of-the-art tool for analyzing TPNs.

Arxiv preprint arXiv:1107.1166, 2011

We introduce a technique for reachability analysis of Time-Basic (TB) Petri nets, a powerful formalism for realtime systems where time constraints are expressed as intervals, representing possible transition firing times, whose bounds are functions of marking's time description. The technique consists of building a symbolic reachability graph relying on a sort of time coverage, and overcomes the limitations of the only available analyzer for TB nets, based in turn on a time-bounded inspection of a (possibly infinite) reachability-tree. The graph construction algorithm has been automated by a tool-set, briefly described in the paper together with its main functionality and analysis capability. A running example is used throughout the paper to sketch the symbolic graph construction. A use case describing a small real system -that the running example is an excerpt from -has been employed to benchmark the technique and the tool-set. The main outcome of this test are also presented in the paper. Ongoing work, in the perspective of integrating with a model-checking engine, is shortly discussed.

Lecture Notes in Computer Science, 2005

We establish mutual translations between the classes of 1safe timed-arc Petri nets (and its extension with testing arcs) and networks of timed automata (and its subclass where every clock used in the guard has to be reset). The presented translations are very tight (up to isomorphism of labelled transition systems with time). This provides a convenient characterization from the theoretical point of view but is not always satisfactory from the practical point of view because of the possible non-polynomial blow up in the size (in the direction from automata to nets). Hence we relax the isomorphism requirement and provide efficient (polynomial time) reductions between networks of timed automata and 1-safe timed-arc Petri nets preserving the answer to the reachability question. This makes our techniques suitable for automatic translation into a format required by tools like UPPAAL and KRONOS. A direct corollary of the presented reductions is a new PSPACE-completeness result for reachability in 1-safe timed-arc Petri nets, reusing the region/zone techniques already developed for timed automata.

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.

Combinatorial Optimization and Theoretical Computer Science, 2008

In this paper we consider the model of Time Petri Nets (TPN) "à la Merlin" where a time interval is associated with the firing of a transition, but we extend it with open intervals. We also consider Timed Automata (TA) as defined by Alur & Dill. We investigate some questions related to expressiveness for these models : we study the impact of slight variations of semantics for TPN and we compare the expressive power of TA and TPN, with respect to both time language acceptance and weak time bisimilarity. We prove that TA and bounded TPNs (enlarged with strict constraints) are equivalent w.r.t. timed language equivalence, providing an efficient construction of a TPN equivalent to a TA. We then exhibit a TA A such that no TPN (even unbounded) is weakly bisimilar to A. Because of this last result, it is natural to try and identify the (strict) subclass of TA that is equivalent to TPN w.r.t. weak timed bisimilarity. Thus we give some further results: 1) we characterize the subclass TA − of TA that is equivalent to the original model of TPN as defined by Merlin, i.e. restricted to closed intervals, 2) we show that the associated membership problem for TA − is P SP ACE-complete and 3) we prove that the reachability problem for TA − is also P SP ACE-complete.

Lecture Notes in Computer Science, 2005

In this paper we consider the model of Time Petri Nets (TPN) where time is associated with transitions. We also consider Timed Automata (TA) as defined by Alur & Dill, and compare the expressiveness of the two models w.r.t. timed language acceptance and (weak) timed bisimilarity. We first prove that there exists a TA A s.t. there is no TPN (even unbounded) that is (weakly) timed bisimilar to A. We then propose a structural translation from TA to (1-safe) TPNs preserving timed language acceptance. Further on, we prove that the previous (slightly extended) translation also preserves weak timed bisimilarity for a syntactical subclass T Asyn(≤, ≥) of TA. For the theory of TPNs, the consequences are: 1) TA, bounded TPNs and 1-safe TPNs are equally expressive w.r.t. timed language acceptance; 2) TA are strictly more expressive than bounded TPNs w.r.t. timed bisimilarity; 3) The subclass T Asyn(≤, ≥), bounded and 1-safe TPNs "à la Merlin" are equally expressive w.r.t. timed bisimilarity.

Petri Nets - Manufacturing and Computer Science, 2012

IEEE Transactions on Systems, Man and Cybernetics, Part B (Cybernetics), 2000

Time Petri nets (TPNs) are a popular Petri net model for specification and verification of real-time systems. A fundamental and most widely applied method for analyzing Petri nets is reachability analysis. The existing technique for reachability analysis of TPNs, however, is not suitable for timing property verification because one cannot derive end-to-end delay in task execution, an important issue for time-critical systems, from the reachability tree constructed using the technique. In this paper, we present a new reachability based analysis technique for TPNs for timing property analysis and verification that effectively addresses the problem. Our technique is based on a concept called clock-stamped state class (CS-class). With the reachability tree generated based on CS-classes, we can directly compute the end-to-end time delay in task execution. Moreover, a CS-class can be uniquely mapped to a traditional state class based on which the conventional reachability tree is constructed. Therefore, our CS-class-based analysis technique is more general than the existing technique. We show how to apply this technique to timing property verification of the TPN model of a command and control (C2) system. Index Terms-Reachability analysis, real-time systems, real-time verification, time Petri nets. I. INTRODUCTION A REAL-TIME system is one whose logical correctness is based both on the correctness of the outputs and on their timeliness [8], [10]. It must satisfy explicit (bounded) response-time constraints or risk severe consequences, including system failure. Consequently, a key requirement to real-time systems is the end-to-end delay in task execution, a critical issue in the design and analysis of these time critical systems [9], [14], [15]. This paper aims to address the timing property analysis and verification of real-time systems. Real-time systems, such as aircraft navigation, command and control, and power plant monitoring systems, are often reactive or embedded control systems that must constantly react to their environment and interact among components within the systems. Consequently, concurrency, resource sharing, synchronization, and deadlock resolution are among essential issues

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.

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.

IFAC Proceedings Volumes, 2014

Automata with weights (multiplicities) in (max,+) algebra form a class of timed automata. Determinism is a crucial property for numerous results on (max,+) automata and, in particular, for applications to performance evaluation and control of a large class of timed discrete event systems. In this paper, we show how to build a deterministic (max,+) automaton equivalent to a live and safe timed Petri net in which any oriented path between any two transitions contains at most one "conflict place".

IEEE Transactions on Industrial Informatics, 2000

Theoretical Computer Science, 1998

We define formally the notion of implementation for time critical systems in terms of provability of properties described abstractly at the specification level. We characterize this notion in terms of formulas of the temporal logic TRIO and operational models of timed Petri nets, and provide a method to prove that two given nets are in the implementation relation. Refinement steps are often used as a means to derive in a systematic way the system design starting from its abstract specification. We present a method to formally prove the correctness of refinement rules for timed Petri nets and apply it to a few simple cases. We show how the possibility to retain properties of the specification in its implementation can simplify the verification of the designed systems by performing incremental analysis at various levels of the specification/implementation hierarchy.

Optimization Techniques

Petri-nets have been found an adequate tool to describe the state transitions of rather complicated systems (as asynchronous systems). Many cocrdinatio~ problems have been modeled successfully with them. However, these models need more information in order to study some quantitative aspects as utilisation rates , delays ..... which are of main interest for a practical point of view. 8o, we are interested in more sophisticated models called Timed Petri-Nets (TPN) in which the time dimension is introduced. In this paper, we first give a formal and rigorous definition of the execution of a TPN ; then, we give some general results on what we call "a program" ; finally, we extend Ramachandani previous results on strongly periodic event graphs to general Petri-nets.