Gioia Ristori

An action-based framework for verifying logical and behavioural properties of concurrent systems

Abstract A system is described which supports proving both behavioural and logical properties of concurrent systems, these are specified by means of a process algebra and its associated logic. The logic is an action based version of the branching time logic CTL, which we call ACTL. It is interpreted over transition labelled structured while CTL is interpreted over state labelled ones. The core of the system are two existing tools, AUTO and EMC. The first builds the labelled transition system corresponding to a term of a process algebra and permits proof of equivalence and simplification of terms, while the second checks the validity of CTL logical formulae. The integration is realized by means of two translation functions from the action based branching time logic ACTL to CTL and from transition-labelled to state-labelled structures. The correctness of the integration is guaranteed by the proof that the two translation functions when coupled preserve satisfiability of logical formulae.

Assisting requirement formalization by means of natural language translation

A prototype assistant, NL2ACTL, is presented for the formalization of behavioural requirements for the design of reactive systems. NL2ACTL is a tool for the automatic translation of Natural Language sentences, into formulae of the action-based temporal logic ACTL. The Natural Language sentences are used to express informal requirements of reactive systems. ACTL is suitable for expressing properties of reactive systems, specified by means of process algebra terms. NL2ACTL was realized using a general development environment for Natural Language Processing and it has been interfaced with a verification environment which allows behavioural and logical properties of reactive systems to be checked.

An Automated Based Verification Environment for Mobile Processes

A verification environment for the π-calculus is presented. The environment takes a direct advantage of a general theory which allows to associate ordinary finite state automata to a wide class of π-calculus agents, so that equivalent automata are associated to equivalent π-calculus agents. A key feature of the approach is the reuse of efficient algorithms and verification techniques which have been developed and implemented for ordinary automata.

An Action Based Framework for Verifying Logical and Behavioural Properties of Concurrent Systems

A system is described which supports proofs of both behavioural and logical properties of concurrent systems; these are specified by means of a process algebra and its associated logics. The logic is an action based version of the branching time logic CTL which we call ACTL; it is interpreted over transition labelled structures while CTL is interpreted over state labelled ones. The core of the system are two existing tools, AUTO and EMC. The first builds the labelled transition system corresponding to a term of a process algebra and permits proof of equivalence and simplification of terms, while the second checks validity of CTL logical formulae. The integration is realized by means of two translation functions from the action based branching time logic ACTL to CTL and from transition-labelled to state-labelled structures. The correctness of the integration is guaranteed by the proof that the two functions when coupled preserve satisfiability of logical formulae.

Model checking for action-based logics

A model checker is described that supports proving logical properties of concurrent systems. The logical properties can be described in different action-based logics (variants of Hennessy-Milner logic). The tools is based on the EMC model checker for the logic CTL. It therefore employs a set of translation functions from the considered logics to CTL, as well as a model translation function from labeled transition systems (models of the action-based logics) to Kripke structures (models for CTL). The obtained tool performs model checking in linear time complexity, and its correctness is guaranteed by the proof that the set of translation functions, coupled with the model translation function, preserves satisfiability of logical formulae.

Verifying hardware components within JACK

JACK (the acronym for Just Another Concurrency Kit) is a workbench integrating a set of verification tools for concurrent system specifications, supported by a graphical interface offering facilities to use these tools separately or in combination. The environment offers several functionalities to support the design, analysis and verification of systems specified using process algebras. In this paper we use JACK to formally specify the hardware components of a buffer system. Then we verify, by using the checking capabilities of JACK, the correctness of the specification with respect to some safety requirements, expressed in the action based temporal logic ACTL.

A Model Checking Algorithm for π-Calculus Agents

This paper presents π-logic, an action-based logic for π-calculus. A model checker is built for this logic, following an automata-based approach. This is made possible by a result which allows finite state Labelled Transition Systems to be associated with a wide class of π-calculus agents by preserving a notion of bisimulation equivalence. The model checker was thus built reusing an efficient model checker for the action based logic Actl, after a sound translation from π-logic into Actl has been defined.

An Exercise in Protocol Verification

The word “verification” is used by various people in many different contexts, and with many different meanings. In the area of parallel and concurrent programming, it refers to activities as different as proof of equivalence between two programs, reachability analysis, the checking of logical properties of a program, or even assertion that a program passes a given test set, or generation of random traces by means of simulation. The verification activities we shall consider here are those directly associated with the analysis of a finite model of the behaviour of a system, namely the building and analysis of such a model, proof of equivalence, and model checking.

Compositionality and bisimulation: a negative result

In the last years there have been several attempts at defining new logics or at using existing ones to specify properties of reactive and concurrent systems. The gain of associating suitable logics, such as modal or temporal logics, to communicating systems is the possibility of using deductive methods to prove properties. To provide modularity in the specification and verification of concurrent systems the compositiorzal denotation by logic assertions of concurrent systems, specified by a process algebra like CCS [ 131, becomes an important research issue [12,16,18]. Compositionality can bz guaranteed by defining a compositional semantics for a process algebra, which associates to each process a logic formula expressing the properties of its execution sequences, e.g., a temporal semantics (a particular denotational semantics [ 141). It is well known that a denotational semantics & is a homomorphism from the term algebra to the interpretation algebra and therefore preserves

A Concurrent Functional Semantics for a Process Algebra Based on Action Systems

In [5, 8] a compositional, algebraic framework is provided in which shared memory systems can be specified and analyzed. The interferences in the use of the shared data are modelled, at the abstract level, by a conflict relation among the actions of the system. The semantic model of the process algebra language is defined in such a way that conflicting actions cannot be executed in parallel, whilst independent actions can. We show in the paper that conflict-based semantics do not allow for exploiting all the parallelism among the activities of a system. Actually, there are functionally equivalent programs (i.e. programs that compute the same final states of the activities and data) which perform conflicting actions in different order. In these situations, conflict-based semantics are not satisfactory, since they put useless sequential constraints on the executions. In this paper we define a concurrent semantics for the process algebra language in [5] which is in agreement with functional equivalence. We propose a model for the language which embeds both concurrent and functional aspects of programs, and takes into account two fundamental topics: the enhancement of the parallelism among the activities of the system, and the functional correctness of its computations. The formalism we use is that of Contextual Condition Event nets [12] (CC/E nets). By using CC/E nets we provide a faithful description of both the data and the activities of a shared memory system, in such a way that each process algebra term can be described by means of a set of net computations. The concurrent semantics of a term is then obtained by associating a structure called O-process [4] with each net computation. This semantics is in full agreement with functional equivalence, i.e. two process algebra terms compute the same final states of the activities and data if and only if they have the same concurrent semantics.