Multiparty Session Types (MPST) are a typing discipline ensuring that a message-passing process implements a given multiparty session protocol, without errors. In this paper, we propose a new, generalised MPST theory. Our contribution is fourfold. (1) We demonstrate that a revision of the theoretical foundations of MPST is necessary: classic MPST have a limited subject reduction property, with inherent restrictions that are easily overlooked, and in previous work have led to flawed type safety proofs; our new theory removes such restrictions and fixes such flaws. (2) We contribute a new MPST theory that is less complicated, and yet more general, than the classic one: it does not require global multiparty session types nor binary session type duality Ð instead, it is grounded on general behavioural type-level properties, and proves type safety of many more protocols and processes. (3) We produce a detailed analysis of type-level properties, showing how, in our new theory, they allow to ensure decidability of type checking, and statically guarantee that processes enjoy, e.g., deadlock-freedom and liveness at run-time. (4) We show how our new theory can integrate type and model checking: type-level properties can be expressed in modal µ-calculus, and verified with well-established tools. CCS Concepts: • Theory of computation → Process calculi; Type structures; Verification by model checking;
Doctoral Thesis A Semantic Deconstruction of Session Types by Alceste Scalas This work investigates the semantic foundations of binary session types, by revisiting First and foremost, I wish to thank my PhD supervisor, Massimo Bartoletti, for his invaluable advice, for the long discussions in front of the whiteboard, and for all the opportunities he gave me to learn new things. The last 3 years have been intense and stimulating, and they certainly represent a pivoting point of my life-both professionally and personally. Massimo's role and influence is difficult to overstate. I also wish to thank Roberto Zunino: our looong Skype meetings have been a fundamental part of my PhD activity, and they have had a huge impact on my work. I am grateful to Simon Gay and Luca Padovani, for reviewing this thesis and giving detailed remarks and helpful suggestions. Thanks to Emilio Tuosto and Nobuko Yoshida for having me as a visiting student at their respective institutions, and for the insightful discussions and fruitful collaboration. During such visits, I also had the opportunity to work with Julien Lange: I am glad that this happened not just once, but twice! Thanks to my (ex-)colleagues at the University of Cagliari-in particular, Giovanni Casu,
Session subtyping is a cornerstone of refinement of communicating processes: a process implementing a session type (i.e., a communication protocol) can be safely used whenever a process implementing one of its supertypes ′ is expected, in any context, without introducing deadlocks nor other communication errors. As a consequence, whenever ⩽ ′ holds, it is safe to replace an implementation of ′ with an implementation of the subtype , which may allow for more optimised communication patterns. This paper presents the first formalisation of the precise subtyping relation for asynchronous multiparty sessions. We show that our subtyping relation is sound (i.e., guarantees safe process replacement, as outlined above) and also complete: any extension of the relation is unsound. To achieve our results, we develop a novel session decomposition technique, from full session types (including internal/external choices) into single input/output session trees (without choices). Previous work studies precise subtyping for binary sessions (with just two participants), or multiparty sessions (with any number of participants) and synchronous interaction. Here, we cover multiparty sessions with asynchronous interaction, where messages are transmitted via FIFO queues (as in the TCP/IP protocol), and prove that our subtyping is both operationally and denotationally precise. In the asynchronous multiparty setting, finding the precise subtyping relation is a highly complex task: this is because, under some conditions, participants can permute the order of their inputs and outputs, by sending some messages earlier or receiving some later, without causing errors; the precise subtyping relation must capture all such valid permutationsand consequently, its formalisation, reasoning and proofs become challenging. Our session decomposition technique overcomes this complexity, expressing the subtyping relation as a composition of refinement relations between single input/output trees, and providing a simple reasoning principle for asynchronous message optimisations. CCS Concepts: • Theory of computation → Process calculi; Type structures.
Concurrent and distributed programming is notoriously hard. Modern languages and toolkits ease this difficulty by offering message-passing abstractions, such as actors (e.g., Erlang, Akka, Orleans) or processes (e.g., Go): they allow for simpler reasoning w.r.t. shared-memory concurrency, but do not ensure that a program implements a given specification.To address this challenge, it would be desirable to specify and verify the intended behaviour of message-passing applications using types, and ensure that, if a program type-checks and compiles, then it will run and communicate as desired.We develop this idea in theory and practice. We formalise a concurrent functional language λ π ⩽ , with a new blend of behavioural types (from π -calculus theory), and dependent function types (from the Dotty programming language, a.k.a. the future Scala 3). Our theory yields four main payoffs: (1) it verifies safety and liveness properties of programs via typelevel model checking; (2) unlike previous work, it accurately verifies channel-passing (covering a typical pattern of actor programs) and higher-order interaction (i.e., sending/receiving mobile code); (3) it is directly embedded in Dotty, as a toolkit called Effpi, offering a simplified actor-based API; (4) it enables an efficient runtime system for Effpi, for highly concurrent programs with millions of processes/actors.
scite is a Brooklyn-based organization that helps researchers better discover and understand research articles through Smart Citations–citations that display the context of the citation and describe whether the article provides supporting or contrasting evidence. scite is used by students and researchers from around the world and is funded in part by the National Science Foundation and the National Institute on Drug Abuse of the National Institutes of Health.
hi@scite.ai
10624 S. Eastern Ave., Ste. A-614
Henderson, NV 89052, USA
Copyright © 2024 scite LLC. All rights reserved.
Made with 💙 for researchers
Part of the Research Solutions Family.