Predicate Transition Nets Research Articles

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.

A Methodology to Analyze Multi-Agent Systems Modeled in High Level Petri Nets

This paper presents a methodology for analyzing multi-agent systems modeled in nested predicate transition nets. The objective is to automate the model analysis for complex systems, and provide a foundation for tool development. We formally define the translation rules that translate the multi-agent model to an executable PROMELA model, and demonstrate the translation with an example.

A METHODOLOGY FOR MODELING MULTI-AGENT SYSTEMS USING NESTED PETRI NETS

In the past two decades, multi-agent systems have emerged as a new paradigm for conceptualizing large and complex distributed software systems. Even though there are many conceptual frameworks for using multi-agent systems, there is no well established and widely accepted method for the representation of multi-agent systems. We adapt a well-known formal model, predicate transition nets, to include the notions of dynamic structure, agent communication and coordination to address the representation problems. This paper presents a comprehensive methodology for modeling multi-agents based on the extensions. We demonstrate our modeling approach with an example. Several case studies on different application domains from our previous works are also discussed.

Formal Modeling and Verification of Security Property in Handel C Program

Multi-million gate system-on-chip (SoC) designs easily fit into today’s Field Programmable Gate Arrays (FPGAs). As FPGAs become more common in safety-critical and mission-critical systems, researchers and designers require information flow guarantees for the FPGAs. Tools for designing a secure system of chips (SOCs) using FPGAs and new techniques to manage and analyze the security properties precisely are desirable. In this work we propose a formal approach to model, analyze and verify a typical set of security properties – noninterference – of Handel C programs using Petri Nets and model checking. This paper presents a method to model Handel C programs using Predicate Transition Nets, a type of Petri Net, and define security properties on the model, plus a verification approach where security properties are checked. Three steps are used. First, a formal specification on the Handel C description using Petri Nets is extracted. Second, the dynamic noninterference properties with respect to the Handel C program statements are defined on the model. To assist in verification, a translation rule from the Petri Nets specification to the Maude programming language is also defined. Thus, the formal specification can be verified against the system properties using model checking. A case study of the pipeline multiplier is discussed to illustrate the concept and validate the approach.

A method to test concurrent systems using architectural specification

In this paper, we discuss a testing method for integration testing of complex and concurrent systems. Integration testing is considered the least well understood and hence is the most problematic level of testing related to concurrent system development. This is so, because integration testing is not completely unit (or code) neither testing nor it is completely system testing. To achieve this goal of improving integration testing, our proposed method exploits architectural specification of concurrent and distributed systems defined in the high level Petri nets, known as Hierarchical Predicate Transition Nets (HPrTNs). More specifically, our testing method implements the separation of concerns strategy to handle both the essential complexity associated with the front-end software development of inherently concurrent and distributed systems, i.e. architectural specification, and the difficulty and cost associated with the back-end development of these systems, namely, software testing.

A formal model-based approach for developing an interoperable mobile agent system

Mobile agents provide an effective and flexible approach to developing complex distributed systems. Formalizing the software architecture of mobile agent systems supports the development of high quality agent systems. In this paper, the software architecture of an interoperable mobile agent system is defined using two-layer predicate transition (PrT) nets. Based on the two-layer PrT net models, a formal model-based approach to develop mobile agents systems is proposed. The approach presented in this paper naturally integrates formal methods and practical approaches in each phase of the development life-cycle of the agent system. The proposed approach for agent systems can also be used to develop other complex software systems.

A Methodology for Architectural Design of Concurrent and Distributed Software Systems

Concurrent and distributed software applications are complex software systems that exploit highly parallel and distributed infrastructure to improve the quality of systems in cost-effective way. In order to assist the development of affordable concurrent and distributed software systems, a more effective approach of utilizing single-based architectural description languages (ADLs) is needed. In this paper, we describe an architectural modeling framework that can be used for specifying and analyzing distributed and concurrent software applications. Our key contribution is an architectural specification framework that integrates four important concepts: (1) an architectural description language known as syntactic theory (ST), (2) a high level Petri nets modeling language known as Hierarchical Predicate Transition Nets (HPrTNs), (3) a Pattern-Based Refinement Technique (PBRT), and (4) a systematic process for deriving architectural specifications from requirement specifications. Moreover, the method is heterogeneous modeling approach that specifies software architecture of a distributed and concurrent system in a top-down manner. The immediate benefits of our heterogeneous approach include: increased system analyzability, comprehensibility, reusability, and flexibility. We describe a case study to show the applicability of our approach.

MODELING AND ANALYZING MULTI-AGENT BEHAVIORS USING PREDICATE/TRANSITION NETS

How agents accomplish a goal task in a multi-agent system is usually specified by multi-agent plans built from basic actions (e.g. operators) of which the agents are capable. The plan specification provides the agents with a shared mental model for how they are supposed to collaborate with each other to achieve the common goal. Making sure that the plans are reliable and fit for the purpose for which they are designed is a critical problem with this approach. To address this problem, this paper presents a formal approach to modeling and analyzing multi-agent behaviors using Predicate/Transition (PrT) nets, a high- level formalism of Petri nets. We model a multi-agent problem by representing agent capabilities as transitions in PrT nets. To analyze a multi-agent PrT model, we adapt the planning graphs as a compact structure for reachability analysis, which is coherent to the concurrent semantics. We also demonstrate that one can analyze whether parallel actions specified in multi-agent plans can be executed in parallel and whether the plans can achieve the goal by analyzing the dependency relations among the transitions in the PrT model.

Requirements specification and analysis of fault-tolerant digital systems

We present an integrated computer-aided design environment, the PrT (predicate/transition) net system, in order to systematically introduce fault-tolerant properties into the design of complicated digital systems. This is accomplished by exploiting a formal specification of the system requirements in which the amount of necessary redundancy can be determined. The system is based on an integration of PrT nets with regular expressions. PrT nets are used to describe and analyze a high level system and regular expressions are used to describe and analyze the more detailed system structures. Both models provide us with well-defined levels of fault diagnosis needed in the digital system design. An S-invariant technique can be used to check the constancy of PrT nets; and a finite state automaton can be used to check the acceptability of regular expressions. Furthermore, the regular expression can also enable a system designer to determine redundancy in order to perform error correction. In consequence, our approach is superior to the current techniques for requirements analysis. Finally, main results are presented in the form of four propositions and supported by some experiments.

AN OBJECT-ORIENTED APPROACH FOR HYBRID SYSTEM MODELLING

This paper presents a novel modelling approach for hybrid industrial plants. It is based on the introduction of object-oriented concepts to the Differential Predicate Transition nets. To handle the system complexity a top-down methodology is considered, where class models are successively refined and decomposed. The UML language is also used to represent different views of the modelled system. A cane sugar factory is used as an example to illustrate the proposed approach.

Modeling, Simulation and Analysis of Batch Production Systems

After a survey of some approaches for modeling hybrid systems by means of Petri nets ( t -time Petri nets, colored Petri nets, hybrid Petri nets and differential predicate transition nets), this pa...

A formal approach for component retrieval and integration analysis

Software reuse has the potential to improve software quality and productivity. Software reuse covers the whole process of identification, representation, retrieval, adaptation and integration of reusable software components. Although object-oriented software has potentially high reusability, retrieving reusable object-oriented software may be difficult when the reuse library is large and inaccessibly represented. Furthermore, it is hard to check the consistency of component integration due to the lack of formal descriptions of required components. In this paper, we propose a formal approach for component retrieval and integration analysis during the reuse process. During the reuse process, software components are specified with logical predicates. A two-layer specification method is proposed. The class-layer specification is used for component retrieval and the member function-layer specification is used for consistency analysis during component integration. A formal model, predicate transition nets, is used for dynamic integration analysis. We show how to derive predicate transition nets from individual components and integrated components, and how to detect potential inconsistencies by checking the reachability tree of the predicate transition net representing an integrated program. Based on the approach proposed in this paper, a comprehensive tool can be implemented. Copyright © 2000 John Wiley & Sons, Ltd.

Translating hierarchical predicate transition nets to CC++ programs

This paper presents an approach to translate hierarchical predicate transition nets into CC++ program skeletons. The approach consists of an overall translation architecture and a set of translation rules based on the syntax and semantics of hierarchical predicate transition nets. Our results have established a link between hierarchical predicate transition nets and concurrent object-oriented programming, and provided some building blocks for a hierarchical predicate transition net based on transformational software development methodology.

Experiences with colored predicate-transition nets for specifying and prototyping embedded systems

Computer systems in today's society require an increasing amount of embedded software and hardware systems. Their application has introduced new problems for the software engineer combined with the complexity of such systems. In particular, the early stages of the software development process are vital for the successful implementation of computer systems. High order Petri nets are introduced and extended as a powerful formalism for the specification and analysis of concurrent systems. A tool called SystemSpecs has been applied that supports rapid system prototyping with such nets. This survey article provides techniques for early systems analysis that can be used as a real time system prototype for customer presentations. Small examples are extracted from industrial applications to indicate how the described techniques can be used. While the major disadvantage of typical net descriptions is their visual complexity that makes them useless for large distributed systems, the paper also describes how to find overly complex structures, and describes selected methods of how to refine such structures.

Developing reusable multi-tasking components using object-oriented techniques in Ada 95

Since 1985, we have undertaken extensive works on concurrent system development methodology and their systematic implementation in Ada. In 1990-1991, this resulted in the presentation of the CODE-TOP (COncurrent system DEvelopment using Transformations Of Predicate-transition nets) methodology [1][2]. Starting from this basis, we later developed a framework of components, using OO techniques, which are reusable to implement in Ada 95 any type exporting synchronization / communication properties [3].This leads us to propose, as a theme for this workshop, the identification, development, and implementation in Ada 95 of general purpose reusable components for concurrent systems. By "general purpose", we mean that these components are not specialized in any specific domain as, for example, communication, or guidance and control systems. This proposal enters perfectly within the goals that were stated in the "Call for Participation" and is more specifically related to the two following goals :"Identify the benefits and impacts of using object-oriented programming in multi-tasking real-time systems";"Explore the use of Ada 95 in developing multi-tasking components that are resilient to software design errors and hardware failures".In section 2, we briefly expose the state of our works, which we already quoted.In section 3, we propose to consider the different possible kinds of reusable multi-tasking components in Ada 95. On one kind of components our works could be a good starting point for discussion.

Structured Petri Nets - An Approach for Specifying Complex Real-time Systems

Applying high order Petri nets to the analysis and specification of real-time software systems supports the graphical representation of both control flows and data flows in one single graph. Execution can be simulated by moving tokens with data sets through the nets, hence supporting rapid prototyping and user-oriented validation of correct functionality and behavior. The paper introduces the use of structured high order Petri nets for specifying, designing and rapid-prototyping real-time software. In addition some restructuring techniques are explained that might help to reduce the complexity of specifications based on such nets. This structured technique for applying predicate transition nets is integrated in a CASE environment and supports real-time simulation or design code generation of sufficiently refined specifications.

Visualizing actor programs using predicate transition nets

The actor model of concurrent computation unifies the functional and object-oriented programming language paradigms. The model provides a flexible basis for concurrent programming. It supports local state, dynamic creation and configuration, and inherent parallelism. Because of the fluidity of actors, specifying and debugging actor systems is often considered difficult. We believe visual programming techniques are of fundamental importance in addressing powerful concurrent systems of this nature. Not surprisingly, a number of methods to visualize actor programs have been proposed. We give an outline of visualization techniques and their relation to actors. We then discuss one such proposal, namely the use of Predicate Transition nets, to visualize actor programs.

Specification and execution of transactions for advanced database applications

Autonomous multidatabases, Computer Aided Design (CAD) databases, and Object Oriented Databases have requirements which traditional transactions cannot meet. Users of these advanced applications are more sophisticated than users envisioned for On Line Transaction Processing (OLTP) applications a few decades ago. The need to relax the properties of complex database transactions is urgent. Frameworks for flexible transaction systems are needed. This paper is a step towards this objective. This paper addresses the formalization of a new transaction model called Flex transactions, along with execution control and analysis protocols. The algorithm is formalized through the use of Predicate Transition Nets (PTN) and reachability trees.

A Train Set as a Case Study for the Requirements Analysis of Safety-Critical Systems

Requirements analysis plays a vital role in the development of safety-critical systems since any faults in the requirements specification will corrupt the subsequent stages of system development. Experience in safety-critical systems has shown that faults in the requirements can and do cause disasters. The analysis of the safety requirements of a train set system is discussed in terms of a general framework for the requirements analysis of safety-critical systems. This framework is based on the clear separation of the mission and safety issues, and also on the separation of the analysis, into two phases, to be performed in terms of the properties of the real world, i.e. physical laws and rules of operation, and the properties of the system, i.e. the mapping of the real world properties in terms of the system sensors and actuators. Due to the different expressive needs of the two phases we propose the utilisation of different formal models, respectively, a logical formalism (Timed History Logic) and a net formalism (Predicate-Transition nets).

Temporal predicate transition nets—a new formalism for specifying and verifying concurrent systems

In this paper, a new type of high-level Petri nets is defined, which is a combination of predicate transition nets and first order temporal logic. By combining these two formalisms together, we can explicitly specify the structure, and specify and verify various properties of concurrent systems in the same framework, which we cannot achieve by using either one of the formalisms alone. Therefore a more powerful formalism for the specification and verification of concurrent systems is obtained. The application of temporal predicate transition nets is illustrated through the specification and verification of the five dining philosophers problem.