2,888 research outputs found
Two sides of the same coin: session types and game semantics
Game semantics and session types are two formalisations of the same concept: message-passing open programs following certain protocols. Game semantics represents protocols as games, and programs as strategies; while session types specify protocols, and well-typed π-calculus processes model programs. Giving faithful models of the π-calculus and giving a precise description of strategies as a programming language are two difficult problems. In this paper, we show how these two problems can be tackled at the same time by building an accurate game semantics model of the session π-calculus. Our main contribution is to fill a semantic gap between the synchrony of the (session) π-calculus and the asynchrony of game semantics, by developing an event-structure based game semantics for synchronous concurrent computation. This model supports the first truly concurrent fully abstract (for barbed congruence) interpretation of the synchronous (session) π-calculus.We further strengthen this correspondence, establishing finite definability of asynchronous strategies by the internal session π-calculus. As an application of these results, we propose a faithful encoding of synchronous strategies into asynchronous strategies by call-return protocols, which induces automatically an encoding at the level of processes. Our results bring session types and game semantics into the same picture, proposing the session calculus as a programming language for strategies, and strategies as a very accurate model of the session calculus. We implement a prototype which computes the interpretation of session processes as synchronous strategies
On the preciseness of subtyping in session types
Subtyping in concurrency has been extensively studied since early 1990s as one of the most interesting issues in type theory. The correctness of subtyping relations has been usually provided as the soundness for type safety. The converse direction, the completeness, has been largely ignored in spite of its usefulness to define the greatest subtyping relation ensuring type safety. This paper formalises preciseness (i.e. both soundness and completeness) of subtyping for mobile processes and studies it for the synchronous and the asynchronous session calculi. We first prove that the well-known session subtyping, the branching-selection subtyping, is sound and complete for the synchronous calculus. Next we show that in the asynchronous calculus, this subtyping is incomplete for type-safety: that is, there exist session types T and S such that T can safely be considered as a subtype of S, but T ≤ S is not derivable by the subtyping. We then propose an asynchronous sub-typing system which is sound and complete for the asynchronous calculus. The method gives a general guidance to design rigorous channel-based subtypings respecting desired safety properties
On Asynchronous Session Semantics
This paper studies a behavioural theory of the π-calculus with session types under the fundamental principles of the practice of distributed computing — asynchronous communication which is order-preserving inside each connection (session), augmented with asynchronous inspection of events (message arrivals). A new theory of bisimulations is introduced, distinct from either standard
asynchronous or synchronous bisimilarity, accurately capturing the semantic nature of session-based asynchronously communicating processes augmented with
event primitives. The bisimilarity coincides with the reduction-closed barbed congruence. We examine its properties and compare them with existing semantics.
Using the behavioural theory, we verify that the program transformation of multithreaded into event-driven session based processes, using Lauer-Needham duality,
is type and semantic preserving
Precise subtyping for synchronous multiparty sessions
The notion of subtyping has gained an important role both in theoretical and applicative domains: in lambda and concurrent calculi as well as in programming languages. The soundness and the completeness, together referred to as the preciseness of subtyping, can be considered from two different points of view: operational and denotational. The former preciseness has been recently developed with respect to type safety, i.e. the safe replacement of a term of a smaller type when a term of a bigger type is expected. The latter preciseness is based on the denotation of a type which is a mathematical object that describes the meaning of the type in accordance with the denotations of other expressions from the language. The result of this paper is the operational and denotational preciseness of the subtyping for a synchronous multiparty session calculus. The novelty of this paper is the introduction of characteristic global types to prove the operational completeness
A type system for components
In modern distributed systems, dynamic reconfiguration, i.e.,
changing at runtime the communication pattern of a program, is chal-
lenging. Generally, it is difficult to guarantee that such modifications will
not disrupt ongoing computations. In a previous paper, a solution to this
problem was proposed by extending the object-oriented language ABS
with a component model allowing the programmer to: i) perform up-
dates on objects by means of communication ports and their rebinding;
and ii) precisely specify when such updates can safely occur in an object
by means of critical sections. However, improper rebind operations could
still occur and lead to runtime errors. The present paper introduces a
type system for this component model that extends the ABS type system
with the notion of ports and a precise analysis that statically enforces
that no object will attempt illegal rebinding
Secure Multiparty Sessions with Topics
Multiparty session calculi have been recently equipped with security
requirements, in order to guarantee properties such as access control and leak
freedom. However, the proposed security requirements seem to be overly
restrictive in some cases. In particular, a party is not allowed to communicate
any kind of public information after receiving a secret information. This does
not seem justified in case the two pieces of information are totally unrelated.
The aim of the present paper is to overcome this restriction, by designing a
type discipline for a simple multiparty session calculus, which classifies
messages according to their topics and allows unrestricted sequencing of
messages on independent topics.Comment: In Proceedings PLACES 2016, arXiv:1606.0540
Session Types as Generic Process Types
Behavioural type systems ensure more than the usual safety guarantees of
static analysis. They are based on the idea of "types-as-processes", providing
dedicated type algebras for particular properties, ranging from protocol
compatibility to race-freedom, lock-freedom, or even responsiveness. Two
successful, although rather different, approaches, are session types and
process types. The former allows to specify and verify (distributed)
communication protocols using specific type (proof) systems; the latter allows
to infer from a system specification a process abstraction on which it is
simpler to verify properties, using a generic type (proof) system. What is the
relationship between these approaches? Can the generic one subsume the specific
one? At what price? And can the former be used as a compiler for the latter?
The work presented herein is a step towards answers to such questions.
Concretely, we define a stepwise encoding of a pi-calculus with sessions and
session types (the system of Gay and Hole) into a pi-calculus with process
types (the Generic Type System of Igarashi and Kobayashi). We encode session
type environments, polarities (which distinguish session channels end-points),
and labelled sums. We show forward and reverse operational correspondences for
the encodings, as well as typing correspondences. To faithfully encode session
subtyping in process types subtyping, one needs to add to the target language
record constructors and new subtyping rules. In conclusion, the programming
convenience of session types as protocol abstractions can be combined with the
simplicity and power of the pi-calculus, taking advantage in particular of the
framework provided by the Generic Type System.Comment: In Proceedings EXPRESS/SOS 2014, arXiv:1408.127
From Lock Freedom to Progress Using Session Types
Inspired by Kobayashi's type system for lock freedom, we define a behavioral
type system for ensuring progress in a language of binary sessions. The key
idea is to annotate actions in session types with priorities representing the
urgency with which such actions must be performed and to verify that processes
perform such actions with the required priority. Compared to related systems
for session-based languages, the presented type system is relatively simpler
and establishes progress for a wider range of processes.Comment: In Proceedings PLACES 2013, arXiv:1312.221
Trees from Functions as Processes
Levy-Longo Trees and Bohm Trees are the best known tree structures on the
{\lambda}-calculus. We give general conditions under which an encoding of the
{\lambda}-calculus into the {\pi}-calculus is sound and complete with respect
to such trees. We apply these conditions to various encodings of the
call-by-name {\lambda}-calculus, showing how the two kinds of tree can be
obtained by varying the behavioural equivalence adopted in the {\pi}-calculus
and/or the encoding
- …