Characterizing behavioural semantics and abstractor semantics

This paper extends to process algebras the notion of maximality which has initially been introduced for prime event structures and P/T nets and shows how this notion of maximality may be used for de ning an adequate semantics of Basic LOTOS able to support action re nement. Such an approach appears to be more convenient than the classical STsemantics where non atomic actions are split into start and end sub-actions, as it makes it possible to escape from the potential state space explosion problems induced by action splitting. Main contributions of the paper are related to the de nition of a maximality-based operational semantics of LOTOS and to the expression of maximality-based bisimulation equivalences which are shown to be preserved under action re nement.

Information and Computation, 2012

We propose a process algebra, the Algebra of Behavioural Types, as a language for typing concurrent objects in process calculi. A type is a higher-order labelled transition system that characterises all possible life cycles of a concurrent object. States represent interfaces of objects; state transitions model the dynamic change of object interfaces. Moreover, a type provides an internal view of the objects that inhabit it: a synchronous one, since transitions correspond to message reception. To capture this internal view of objects we define a notion of bisimulation, strong on labels and weak on silent actions. We study several algebraic laws that characterise this equivalence, and obtain completeness results for image-finite types.

Formal Methods for Open Object-Based Distributed Systems, 1999

In the object-oriented languages, inheritance is a fundamental relation among classes, that originally indicated the is-a relation; however it has been often used for code-reuse. The integration between object-orientation and concurrency gives the possibility of using theoretical tools, such as the notions of action and state observation equivalences and preorders, developed within concurrency theories (Petri nets, CCS). In this paper we propose a semantic characterisation of two forms of inheritance in concurrent context: in particular, we propose a preorder based on action observation to give the semantics of inheritance used as is-a relation (type inheritance), and a preorder based on state observation for the semantics of inheritance as code-reuse (implementation inheritance).

arXiv (Cornell University), 2010

In this paper we introduced an algebraic semantics for process algebra in form of abstract data types. For that purpose, we developed a particular type of Σ algebra, the seed algebra, which describes exactly the behavior of a process within a labeled transition system. We have shown the possibility of characterizing the bisimulation of two processes with the isomorphism of their corresponding seed algebras. We pointed out that the traditional concept of isomorphism of algebra does not apply here, because there is even no one-one correspondence between the elements of two seed algebras. The lack of this one-one correspondence comes from the non-deterministic choice of transitions of a process. We introduce a technique of hidden operations to mask unwanted details of elements of a seed algebra, which only reflect non-determinism or other implicit control mechanism of process transition. Elements of a seed algebra are considered as indistinguishable if they show the same behavior after these unwanted details are masked. Each class of indistinguishable elements is called a non-hidden closure. We proved that bisimulation of two processes is equivalent to isomorphism of non-hidden closures of two seed algebras representing these two processes. We call this kind of isomorphism a deep isomorphism. We get different models of seed algebra by specifying different axiom systems for the same signature. Each model corresponds to a different kind of bisimulation. By proving the relations between these models we also established relations between 10 different bisimulations, which form a acyclic directed graph.

Foundation of Software …, 1994

More than 15 years ago, Cleaveland and Hennessy proposed an extension of the process algebra CCS in which some actions may take priority over others. The theory was equipped with a behavioral congruence based on strong bisimulation.

Lecture Notes in Computer Science, 1996

The paper summarizes the main concepts and paradigms of category theory and explores some of their applications to the area of algebraic speci cations. In detail we discuss di erent approaches to an abstract theory of speci cation logics. Further we present a uniform framework for developing particular speci cation logics. We make use of`classifying categories', to present categories of algebras as functor categories and to obtain necessary basic results for particular speci cation logics in a uniform manner. The speci cation logics considered are: equational logic for total algebras, conditional equational logic for partial algebras, and rewrite logic for concurrent systems. Category theory arose from the fundamental idea of representing a function by an arrow. This idea rst appeared in topology about 1940 (see Mac71]). The orig-' Funct PROD AT(Colim j SPEC j); SET ] ' Funct PROD Colim j AT(SPEC j); SET ] ' Lim j Funct PROD AT(SPEC j); SET ] ' Lim j Mod(SPEC j) Let's sum up the results for SET {models for the general approach as

There exists a rich literature of rule formats guaranteeing different algebraic properties for formalisms with a Structural Operational Semantics. Moreover, there exist a few approaches for automatically deriving axiomatizations characterizing strong bisimilarity of processes. To our knowledge, this literature has never been extended to the setting with data (e.g. to model storage and memory). We show how the rule formats for algebraic properties can be exploited in a generic manner in the setting with data. Moreover, we introduce a new approach for deriving sound and ground-complete axiom schemata for a notion of bisimilarity with data, called stateless bisimilarity, based on intuitive auxiliary function symbols for handling the store component. We do restrict, however, the axiomatization to the setting where the store component is only given in terms of constants.

Mathematical Foundations of Programming Semantics, 1994