ETOILE-specifications: An Object-oriented Algebraic Formalism with Refinement

This article describes first steps towards the formal specification and verification of multi-agent systems, through the use of temporal belief logics. The article first describes Concurrent METATEM, a multi-agent programming language, and then develops a logic that may be used to reason about Concurrent METATEM systems. The utility of this logic for specifying and verifying Concurrent METATEM systems is demonstrated through a number of examples. The article concludes with a brief discussion on the wider implications of the work, and in particular on the use of similar logics for reasoning about multi-agent systems in general.

Object-oriented systems have provided a new methodology for decomposing problems. They have also brought out the issue of the specification of concurrency in a more structured manner. The paper shows how the Parallel Objects (PO) model addresses the problem of supporting concurrency. PO is a parallel object-oriented model. Any entity/object is capable of independent execution and in addition several concurrent activities can exist within the same object. In fact, as a feature distinguished from other concurrent object systems, PO does not strive to obtain intra-object sequentialization. In PO, the specification of concurrency can take advantage of a layered approach. Depending on user skill, the system requires more or less deep insight of PO to specify concurrency. A novice user can derive the specification of object concurrency from the PO environment. This approach stresses the reuse principle typical of object systems, i.e., inheritance. The PO environment makes it possible for skilled users to investigate complex concurrency policies and their performances for the same application.

Creol is an object-oriented modeling language in which inherently concurrent objects exchange asynchronous method calls. The operational semantics of Creol is written in an actor-based style, formulated in rewriting logic. The operational semantics yields a language interpreter in the Maude system, which can be used to analyze models. Recently, Creol has been applied to the modeling of systems with radio communication, such as sensor systems. With radio communication, messages expire and, if sent simultaneously, they may collide in the air. In order to capture these and other properties of distributed systems, we extended Creol's operational semantics with a notion of time. We exploit the framework of a language interpreter to use a lightweight notion of time, in contrast to that needed for a general purpose specification language. This paper presents a timed extension of Creol, including the semantics and the implementation strategy, and discusses its properties using an extended example. The approach can be generalized to other concurrent object or actor-based systems.

The lack of formalism and rigor in existing multi-agents models often leads to ambiguities and different interpretations. Those weaknesses combined with the inherent complexity of multi-agents systems generate many problems in their development process. Using formal notations to specify multi-agents systems’ behavior makes it possible to produce precise description. This also offers a better support to their verification and validation process. The Maude language, based on rewriting logic, presents a rich notation supporting formal specification and implementation of concurrent systems. In this paper, we demonstrate the feasibility and the interest of formalizing the behavior of DIMA model’s agents with the Maude language. The elaborated formal approach captures the inherent aspects of a DIMA model. The generated Maude descriptions have been validated using the platform supporting this language. Moreover, the proposed approach is generic and extensible. It offers, in particular, the advantage of being applicable to all multi-agents systems based on DIMA architecture and presents interesting extension possibilities.

Architectures based on Coordinated Atomic action (CA action) concepts have been used to build concurrent fault-tolerant systems. This conceptual model combines concurrent exception handling with action nesting to provide a general mechanism for both enclosing interactions among system components and coordinating forward error recovery measures. This paper proposes an architectural model to guide the formal specification of concurrent fault-tolerant systems. This architecture provides built-in CSP (Communicating Sequential Process) processes and predefined channels to coordinate exception handling of the user-defined components. As a result, a formal and general architecture supporting software fault-tolerance are ready to be used.

The formal specification of concurrent systems: a small CCS case study

Formal Verification of Object-Oriented Graph Grammars Specifications

With the increasing use of active object systems, agents and concurrent object oriented languages like Java, the problem of garbage collection of unused resources has become more complicated. Since Active objects are standalone computational agents identifying garbage in active objects system cannot be based on reachability from a root set (which we use for passive objects). We have to go for separate algorithm to collect garbage on system which uses active objects. For the systems which use both active and passive objects we have to use 2 separate methods for collecting garbage. To avoid this we can use a transformation algorithm that can transfer active object reference graph into passive object reference graph, after which we can apply the passive object algorithm to collect garbage from the entire system. An attempt is made to travel through the transformation algorithms.KeywordsActive ObjectsGarbage CollectionPassive ObjectsDistributed Garbage CollectionTransformation Algorithm

We develop a logic-based framework for formal specification and algorithmic verification of homogeneous and dynamic concurrent multi-agent transition systems. Homogeneity means that all agents have the same available actions at any given state and the actions have the same effects regardless of which agents perform them. The state transitions are therefore determined only by the vector of numbers of agents performing each action and are specified symbolically, by means of conditions on these numbers definable in Presburger arithmetic. The agents are divided into controllable (by the system supervisor/controller) and uncontrollable, representing the environment or adversary. Dynamicity means that the numbers of controllable and uncontrollable agents may vary throughout the system evolution, possibly at every transition. As a language for formal specification we use a suitably extended version of Alternating-time Temporal Logic, where one can specify properties of the type “a coalition of (at least) n controllable agents can ensure against (at most) m uncontrollable agents that any possible evolution of the system satisfies a given objective gamma″, where gamma is specified again as a formula of that language and each of n and m is either a fixed number or a variable that can be quantified over. We provide formal semantics to our logic {mathcal {L}}_{textsc {hdmas}} and define normal form of its formulae. We then prove that every formula in {mathcal {L}}_{textsc {hdmas}} is equivalent in the finite to one in a normal form and develop an algorithm for global model checking of formulae in normal form in finite HDMAS models, which invokes model checking truth of Presburger formulae. We establish worst case complexity estimates for the model checking algorithm and illustrate it on a running example.

Summary form only given. We are developing a specification and proof environment, called PREVAIL, which is to support several input languages (currently, only VHDL is supported) and which proposes a set of proof tools to verify appropriate descriptions/specifications. Nqthm is one of these tools, and we are working at defining an induction-based method to validate concurrent systems using this prover. To give such systems a formal specification, our first task was to choose between VHDL and one of the formal languages that can be of interest to hardware/software developers. Using a simple but significant reactive system as a running example, we give a comparative evaluation of VHDL and two formal languages: the ISO Formal Description Technique LOTOS, and the computational model UNITY. Thus we draw conclusions about the accuracy of each one of them with respect to different aspects (sequential behaviours, communications, non determinism, fairness, etc.).

While waiting for the millennium: Formal specification and verification of concurrent systems now

In this paper we present our approach allowing the translation of Real Time Multi-Agents Systems (RT-MAS) organizational requirements described by extended AUML (Agent UML Language) diagrams into a formal specification written in Real Time Maude language (RT-Maude). In fact, the approach is an extension of our previous work [1] that consists in extending AUML diagrams (Temporal AUML organization use case diagram and Temporal AUML organization class diagram) by using stereotypes notions and meta-model organizations entities for taking into account RT-MAS specificities. Once elaborated, these different diagrams undergo a validation to assure inter-and intra model coherence. The formal and object oriented language RT-Maude, base on rewriting logic, supports formal specification and programming of concurrent systems. The main motivations of this work are: (1) formalizing the organizational requirements of RT-MAS by using RT-Maude language, and (2) integrating the validation of the coherence models, since the analysis phase.

This book is a celebration of Leslie Lamport's work on concurrency, interwoven in four-and-a-half decades of an evolving industry: from the introduction of the first personal computer to an era when parallel and distributed multiprocessors are abundant. His works lay formal foundations for concurrent computations executed by interconnected computers. Some of the algorithms have become standard engineering practice for fault tolerant distributed computing - distributed systems that continue to function correctly despite failures of individual components. He also developed a substantial body of work on the formal specification and verification of concurrent systems, and has contributed to the development of automated tools applying these methods. Part I consists of technical chapters of the book and a biography. The technical chapters of this book present a retrospective on Lamport's original ideas from experts in the field. Through this lens, it portrays their long-lasting impact. The chapters cover timeless notions Lamport introduced: the Bakery algorithm, atomic shared registers and sequential consistency; causality and logical time; Byzantine Agreement; state machine replication and Paxos; temporal logic of actions (TLA). The professional biography tells of Lamport's career, providing the context in which his work arose and broke new grounds, and discusses LaTeX - perhaps Lamport's most influential contribution outside the field of concurrency. This chapter gives a voice to the people behind the achievements, notably Lamport himself, and additionally the colleagues around him, who inspired, collaborated, and helped him drive worldwide impact. Part II consists of a selection of Leslie Lamport's most influential papers. This book touches on a lifetime of contributions by Leslie Lamport to the field of concurrency and on the extensive influence he had on people working in the field. It will be of value to historians of science, and to researchers and students who work in the area of concurrency and who are interested to read about the work of one of the most influential researchers in this field.

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.

The conceptual modeling of the Universe of Discourse (UoD) is an important phase for the development of information systems because the conceptual model is the basis for system development. Conceptual model specifications must be formal in order to be precise and unambiguous and to support consistency and completeness checks. The object-oriented paradigm is suitable for providing an integrated formal description of all relevant static and dynamic aspects of the UoD structured in objects. In this paper we introduce a formal concept of object suitable to represent the UoD by a collection of concurrent interacting objects. The Oblog +-language for object-oriented UoD-specification based on this concept supports the integrated description of data about objects, the development of objects through time and of various relationships between objects taking into account static and dynamic aspects of object interaction.