Observed Communication Semantics for Classical Processes

We present Hypersequent Classical Processes (HCP), a revised interpretation of the "Proofs as Processes" correspondence between linear logic and the π -calculus initially proposed by Abramsky [1994], and later developed by Bellin and Scott [1994], Caires and Pfenning [2010], and Wadler [2014], among others. HCP mends the discrepancies between linear logic and the syntax and observable semantics of parallel composition in the π -calculus, by conservatively extending linear logic to hyperenvironments (collections of environments, inspired by the hypersequents by Avron [1991]). Separation of environments in hyperenvironments is internalised by ⊗ and corresponds to parallel process behaviour. Thanks to this property, for the first time we are able to extract a labelled transition system (lts) semantics from proof rewritings. Leveraging the information on parallelism at the level of types, we obtain a logical reconstruction of the delayed actions that Merro and Sangiorgi [2004] formulated to model non-blocking I/O in the π -calculus. We define a denotational semantics for processes based on Brzozowski derivatives, and uncover that non-interference in HCP corresponds to Fubini's theorem of double antiderivation. Having an lts allows us to validate HCP using the standard toolbox of behavioural theory.We instantiate bisimilarity and barbed congruence for HCP, and obtain a full abstraction result: bisimilarity, denotational equivalence, and barbed congruence coincide.Additional Key Words and Phrases: Linear Logic, Concurrency, Behavioural Theory INTRODUCTIONBackground. Since its introduction by Girard [1987], linear logic has been tremendously influential in the study of concurrency. Abramsky [1994], and later Bellin and Scott [1994], kickstarted the search for a direct correspondence between proofs in linear logic and processes in (a fragment of) the π -calculus. This direction is appealing because it carries the hope of providing canonical foundations for concurrency, ideally as firm as those provided by the Curry-Howard correspondence between natural deduction and the simply-typed λ-calculus for functional programming.These initial efforts inspired seminal typing disciplines for the π -calculus, e.g., session types by Honda et al. [1998] and linear types by Kobayashi et al. [1999].Caires and Pfenning [2010] recently revitalised this research line, by developing a correspondence between a variant of the session-typed π -calculus and intuitionistic linear logic: processes correspond to proofs, session types (communication protocols) to propositions, and communication to cut elimination. Wadler [2014] revisited the correspondence for Classical Linear Logic (CLL) and developed the calculus of Classical Processes (CP).The problem. Despite these recent successes, it is still unclear how we can obtain a unified foundation for concurrency based on linear logic and the π -calculus. This is due to a series of discrepancies between the two theories, both on the levels of syntax and semantics-ultimately, we will see that bridgi...

Section: Discussionmentioning

confidence: 99%

Section: Denotational Semanticsmentioning

confidence: 99%

Better late than never: a fully-abstract semantics for classical processes

Kokke

Montesi

Peressotti

2019

“…As the example of the previous section shows, CSLL is a particularly low-level language. This is a feature of essentially all variants of linear logic as used for session typing, including Kokke et al's HCP [2019a, Example 2.1], and Wadler's CP [Atkey 2017, ğ2.1] [Atkey et al 2016. Consequently, the need for higher-level notation to help us write richer examples arises.…”

Section: A Session-typed Language For Client-server Programmingmentioning

confidence: 99%

“…Over the past decade many variations of this language have been proposed; see e.g. Lindley and Morris [2015, 2017 and Fowler et al [2019]. CSGV extends Wadler's version with primitives for client-server interaction.…”

Section: A Session-typed Language For Client-server Programmingmentioning

confidence: 99%

Client-server sessions in linear logic

Qian

Kavvos

Birkedal

2021

We introduce coexponentials, a new set of modalities for Classical Linear Logic. As duals to exponentials, the coexponentials codify a distributed form of the structural rules of weakening and contraction. This makes them a suitable logical device for encapsulating the pattern of a server receiving requests from an arbitrary number of clients on a single channel. Guided by this intuition we formulate a system of session types based on Classical Linear Logic with coexponentials, which is suited to modelling client-server interactions. We also present a session-typed functional programming language for client-server programming, which we translate to our system of coexponentials.

“…The above systems address reliability (if at all) for individual internal messages, not providing application-level guarantees. More recently, Atkey [2017] adds external communication to classical processes, with a focus on the external high-level behavior, bringing the abstraction level closer to our goals for F R . v. Gleissenthall et al [2019] extracts typical communication structures from programs with only minimal annotations, and generates a synchronous model for those communications for which proofs apply to the original asynchronous program.…”

Section: Formal Models For Concurrent and Distributed Computationsmentioning

confidence: 99%

A fault-tolerant programming model for distributed interactive applications

Mogk

Drechsler

Salvaneschi

et al. 2019

Ubiquitous connectivity of web, mobile, and IoT computing platforms has fostered a variety of distributed applications with decentralized state. These applications execute across multiple devices with varying reliability and connectivity. Unfortunately, there is no declarative fault-tolerant programming model for distributed interactive applications with an inherently decentralized system model. We present a novel approach to automating fault tolerance using high-level programming abstractions tailored to the needs of distributed interactive applications. Specifically, we propose a calculus that enables formal reasoning about applications' dataflow within and across individual devices. Our calculus reinterprets the functional reactive programming model to seamlessly integrate its automated state change propagation with automated crash recovery of device-local dataflow and disconnection-tolerant distribution with guaranteed automated eventual consistency semantics based on conflict-free replicated datatypes. As a result, programmers are relieved of handling intricate details of distributing change propagation and coping with distribution failures in the presence of interactivity. We also provides proofs of our claims, an implementation of our calculus, and an empirical evaluation using a common interactive application. CCS Concepts: • Theory of computation → Distributed computing models; • Software and its engineering → Software fault tolerance; Data flow languages.