4,682 research outputs found
A logical foundation for session-based concurrent computation
Linear logic has long been heralded for its potential of providing a logical basis for concurrency.
While over the years many research attempts were made in this regard, a Curry-Howard correspondence between linear logic and concurrent computation was only found recently, bridging the proof theory of linear logic and session-typed process calculus. Building upon this work, we have
developed a theory of intuitionistic linear logic as a logical foundation for session-based concurrent computation, exploring several concurrency related phenomena such as value-dependent session
types and polymorphic sessions within our logical framework in an arguably clean and elegant way, establishing with relative ease strong typing guarantees due to the logical basis, which ensure the fundamental properties of type preservation and global progress, entailing the absence of deadlocks
in communication.
We develop a general purpose concurrent programming language based on the logical interpretation, combining functional programming with a concurrent, session-based process layer through the form of a contextual monad, preserving our strong typing guarantees of type preservation and
deadlock-freedom in the presence of general recursion and higher-order process communication.
We introduce a notion of linear logical relations for session typed concurrent processes, developing an arguably uniform technique for reasoning about sophisticated properties of session-based concurrent computation such as termination or equivalence based on our logical approach, further supporting our goal of establishing intuitionistic linear logic as a logical foundation for sessionbased concurrency
PLACES'10: The 3rd Workshop on Programmng Language Approaches to concurrency and Communication-Centric Software
Paphos, Cyprus. March 201
Uniqueness Typing for Resource Management in Message-Passing Concurrency
We view channels as the main form of resources in a message-passing
programming paradigm. These channels need to be carefully managed in settings
where resources are scarce. To study this problem, we extend the pi-calculus
with primitives for channel allocation and deallocation and allow channels to
be reused to communicate values of different types. Inevitably, the added
expressiveness increases the possibilities for runtime errors. We define a
substructural type system which combines uniqueness typing and affine typing to
reject these ill-behaved programs
Logical Relations for Session-Typed Concurrency
Program equivalence is the fulcrum for reasoning about and proving properties
of programs. For noninterference, for example, program equivalence up to the
secrecy level of an observer is shown. A powerful enabler for such proofs are
logical relations. Logical relations only recently were adopted for session
types -- but exclusively for terminating languages. This paper scales logical
relations to general recursive session types. It develops a logical relation
for progress-sensitive noninterference (PSNI) for intuitionistic linear logic
session types (ILLST), tackling the challenges non-termination and concurrency
pose, and shows that logical equivalence is sound and complete with regard to
closure of weak bisimilarity under parallel composition, using a
biorthogonality argument. A distinguishing feature of the logical relation is
its stratification with an observation index (as opposed to a step or unfolding
index), a crucial shift to make the logical relation closed under parallel
composition in a concurrent setting. To demonstrate practicality of the logical
relation, the paper develops an information flow control (IFC) refinement type
system for ILLST, with support of secrecy-polymorphic processes, and shows that
well-typed programs are self-related by the logical relation and thus enjoy
PSNI. The refinement type system has been implemented in a type checker,
featuring local security theories to support secrecy-polymorphic processes.Comment: arXiv admin note: text overlap with arXiv:2208.1374
Multiparty Sessions based on Proof Nets
We interpret Linear Logic Proof Nets in a term language based on Solos
calculus. The system includes a synchronisation mechanism, obtained by a
conservative extension of the logic, that enables to define non-deterministic
behaviours and multiparty sessions.Comment: In Proceedings PLACES 2014, arXiv:1406.331
Characteristic Bisimulation for Higher-Order Session Processes
Characterising contextual equivalence is a long-standing issue for higher-order (process) languages. In the setting of a higher-order pi-calculus with sessions, we develop characteristic bisimilarity, a typed bisimilarity which fully characterises contextual equivalence. To our knowledge, ours is the first characterisation of its kind. Using simple values inhabiting (session) types, our approach distinguishes from untyped methods for characterising contextual equivalence in higher-order processes: we show that observing as inputs only a precise finite set of higher-order values suffices to reason about higher-order session processes. We demonstrate how characteristic bisimilarity can be used to justify optimisations in session protocols with mobile code communication
Safe Session-Based Concurrency with Shared Linear State
Publisher Copyright: © 2023, The Author(s).We introduce CLASS, a session-typed, higher-order, core language that supports concurrent computation with shared linear state.publishersversionpublishe
Domain-Aware Session Types
We develop a generalization of existing Curry-Howard interpretations of (binary) session types by relying on an extension of linear logic with features from hybrid logic, in particular modal worlds that indicate domains. These worlds govern domain migration, subject to a parametric accessibility relation familiar from the Kripke semantics of modal logic. The result is an expressive new typed process framework for domain-aware, message-passing concurrency. Its logical foundations ensure that well-typed processes enjoy session fidelity, global progress, and termination. Typing also ensures that processes only communicate with accessible domains and so respect the accessibility relation.
Remarkably, our domain-aware framework can specify scenarios in which domain information is available only at runtime; flexible accessibility relations can be cleanly defined and statically enforced. As a specific application, we introduce domain-aware multiparty session types, in which global protocols can express arbitrarily nested sub-protocols via domain migration. We develop a precise analysis of these multiparty protocols by reduction to our binary domain-aware framework: complex domain-aware protocols can be reasoned about at the right level of abstraction, ensuring also the principled transfer of key correctness properties from the binary to the multiparty setting
- …