In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [G.D. Plotkin, A structural approach to operational semantics, Technical

Bialgebraic semantics, invented a decade ago by Turi and Plotkin, is an approach to formal reasoning about well-behaved structural operational specifications. An extension of algebraic and coalgebraic methods, it abstracts from concrete notions of syntax and system behaviour, thus treating various kinds of operational descriptions in a uniform fashion. In this talk, the current state of the art in the area of bialgebraic semantics is presented, and its prospects for the future are sketched. In particular, a combination of basic bialgebraic techniques with a categorical approach to modal logic is described, as an abstract approach to proving compositionality by decomposing modal logics over structural operational specifications. Keywords:

Dynamic logic, broadly conceived, is the logic that analyses change by decomposing actions into their basic building blocks and by describing the results of performing actions in given states of the world. The actions studied by dynamic logic can be of various kinds: actions on the memory state of a computer, actions of a moving robot in a closed world, interactions between cognitive agents performing given communication protocols, actions that change the common ground between speaker and hearer in a conversation, actions that change the contextually available referents in a conversation, and so on. In each of these application areas, dynamic logics can be used to model the states involved and the transitions that occur between them. Dynamic logic is a tool for both state description and action description. Formulae describe states, while actions or programs express state change. The levels of state descriptions and transition characterisations are connected by suitable operations that allow reasoning about pre- and postconditions of particular changes.

Types are the central organizing principle of the theory of programming languages. Language features are manifestations of type structure. The syntax of a language is governed by the constructs that define its types, and its semantics is determined by the interactions among those constructs. The soundness of a language design—the absence of ill-defined programs— follows naturally. The purpose of this book is to explain this remark. A variety of programming language features are analyzed in the unifying framework of type theory. A language feature is defined by its statics, the rules governing the use of the feature in a program, and its dynamics, the rules defining how programs using this feature are to be executed. The concept of safety emerges as the coherence of the statics and the dynamics of a language. In this way we establish a foundation for the study of programming languages. But why these particular methods? Though it would require a book in itself to substantiate this assertion, the type-theoretic approach

We present a study of the interaction properties of multiagent systems where agents communicate by means of speech act based primitives. We identify a set of basic interaction mechanisms: agent identity, asynchronous message passing, implicit receive primitive, which are closed to those of the actor model. Then, we define an actor algebra over actor terms as a basic formalism for multiagent systems. Finally, we show how it is possible to translate a speech act based language (a subset of KQML) into the given algebra. This allows to prove the equivalence of multiagent systems in terms of the equivalence of the corresponding actor terms. multiagent systems

This work develops an integrated approach to the verification of behaviourally rich programs, founded directly on operational semantics. The power of the approach is demonstrated with a stateof-the-art verification of a core piece of distributed infrastructure, involving networking, a filesystem, and concurrent OCaml code. The formalization is in higher-order logic and proof support is provided by the HOL4 theorem prover. Difficult verification problems demand a wide range of techniques. Here these include ground and symbolic evaluation, local reasoning, separation, invariants, Hoare-style assertional reasoning, rely/guarantee, inductive reasoning about protocol correctness, multiple refinement, and linearizability. While each of these techniques is useful in isolation, they are even more so in combination. The first contribution of this paper is to present the operational approach and describe how existing techniques, including all those mentioned above, may be cleanly and precisely integrated in this setting. The second contribution is to show how to combine verifications of individual library functions with arbitrary and unknown user code in a compositional manner, focusing on the problems of private state and encapsulation. The third contribution is the example verification itself. The infrastructure must behave correctly under arbitrary patterns of host and network failure, whilst for performance reasons the code also includes data races on shared state. Both features make the verification particularly challenging.

Abstract. We consider a semantics for a class-based object-oriented calculus based upon approximation; since in the context of LC such a semantics enjoys a strong correspondence with intersection type assignment systems, we also define such a system for our calculus and show that it is sound and complete. We establish the link with between type (we use the terminology predicate here) assignment and the approximation semantics by showing an approximation result, which leads to a sufficient condition for head-normalisation and termination. We show the expressivity of our predicate system by defining an encoding of Combinatory Logic (and so also LC) into our calculus. We show that this encoding preserves predicate-ability and also that our system characterises the normalising and strongly normalising terms for this encoding, demonstrating that the great analytic capabilities of these predicates can be applied to OO. 1

The paper presents a simple format for typed logics with states by adding a function for register update to standard typed lambda calculus. It is shown that universal validity of equality for this extended language is decidable (extending a well-known result of Friedman for typed lambda calculus). This system is next extended to a full fledged typed dynamic logic, and it is illustrated how the resulting format allows for very simple and intuitive representations of dynamic semantics for natural language and denotational semantics for imperative programming. The proposal is compared with some alternative approaches to formulating typed versions of dynamic logics. 1991 Mathematics Subject Classification: 03B15, 03B65, 03B70, 68Q55, 68Q65 1991 Computing Reviews Classification System: D.3.3, F.3.2, I.2.4, I.2.7 Keywords and Phrases: Type theory, compositionality, denotational semantics, dynamic semantics Note: Work carried out under project P4303; paper accepted for publication in the ...

. The aim of this paper is to advocate the use of bisimulation relations in the verication of innite-state or parameterized systems, and demonstrates the support that general-purpose theorem provers can oer. A powerful proof technique, known as up to expansion, is discussed and applied in a case study about write invalidate cache coherence. This example is of interest, as the system is parameterized in the number of its components, and the bisimulation relation reects the coherence of the caches with the main memory. 1 Introduction In recent years, general-purpose theorem proving has come to play an important role in the verication of concurrent systems, especially for systems which are too large to be treated fully automatically, or even innite. Yet, if one is not to use the tool as a mere proof checker, some attention has to be spent on the choice of a suitable methodology. (1) Although generalpurpose theorem provers like Isabelle, PVS, or Coq, oer a considerable amount of au...

Abstract. This paper describes an undergraduate course taught at the University of Newcastle upon Tyne; the title of the module is Understanding Programming Languages. The main thrust of the course is to understand how to model features of language semantics. Specifically, (structural) operational semantics (SOS) is taught as a convenient and notational light way of recording and experimenting with features of procedural programming languages. We outline the content, discuss the contentious issue of tool support and relate experiences. 1