6,778 research outputs found
Relating state-based and process-based concurrency through linear logic (full-version)
AbstractThis paper has the purpose of reviewing some of the established relationships between logic and concurrency, and of exploring new ones.Concurrent and distributed systems are notoriously hard to get right. Therefore, following an approach that has proved highly beneficial for sequential programs, much effort has been invested in tracing the foundations of concurrency in logic. The starting points of such investigations have been various idealized languages of concurrent and distributed programming, in particular the well established state-transformation model inspired by Petri nets and multiset rewriting, and the prolific process-based models such as the π-calculus and other process algebras. In nearly all cases, the target of these investigations has been linear logic, a formal language that supports a view of formulas as consumable resources. In the first part of this paper, we review some of these interpretations of concurrent languages into linear logic and observe that, possibly modulo duality, they invariably target a small semantic fragment of linear logic that we call LVobs.In the second part of the paper, we propose a new approach to understanding concurrent and distributed programming as a manifestation of logic, which yields a language that merges those two main paradigms of concurrency. Specifically, we present a new semantics for multiset rewriting founded on an alternative view of linear logic and specifically LVobs. The resulting interpretation is extended with a majority of linear connectives into the language of ω-multisets. This interpretation drops the distinction between multiset elements and rewrite rules, and considerably enriches the expressive power of standard multiset rewriting with embedded rules, choice, replication, and more. Derivations are now primarily viewed as open objects, and are closed only to examine intermediate rewriting states. The resulting language can also be interpreted as a process algebra. For example, a simple translation maps process constructors of the asynchronous π-calculus to rewrite operators. The language of ω-multisets forms the basis for the security protocol specification language MSR 3. With relations to both multiset rewriting and process algebra, it supports specifications that are process-based, state-based, or of a mixed nature, with the potential of combining verification techniques from both worlds. Additionally, its logical underpinning makes it an ideal common ground for systematically comparing protocol specification languages
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
Fluent temporal logic for discrete-time event-based models
Fluent model checking is an automated technique for verifying that an event-based operational model satisfies some state-based declarative properties. The link between the event-based and state-based formalisms is defined through fluents which are state predicates whose value are determined by the occurrences of initiating and terminating events that make the fluents values become true or false, respectively. The existing fluent temporal logic is convenient for reasoning about untimed event-based models but difficult to use for timed models. The paper extends fluent temporal logic with temporal operators for modelling timed properties of discrete-time event-based models. It presents two approaches that differ on whether the properties model the system state after the occurrence of each event or at a fixed time rate. Model checking of timed properties is made possible by translating them into the existing untimed framework. Copyright 2005 ACM
Towards an embedding of Graph Transformation in Intuitionistic Linear Logic
Linear logics have been shown to be able to embed both rewriting-based
approaches and process calculi in a single, declarative framework. In this
paper we are exploring the embedding of double-pushout graph transformations
into quantified linear logic, leading to a Curry-Howard style isomorphism
between graphs and transformations on one hand, formulas and proof terms on the
other. With linear implication representing rules and reachability of graphs,
and the tensor modelling parallel composition of graphs and transformations, we
obtain a language able to encode graph transformation systems and their
computations as well as reason about their properties
Conflict vs causality in event structures
Event structures are one of the best known models for concurrency. Many variants of the basic model and many possible notions of equivalence for them have been devised in the literature. In this paper, we study how the spectrum of equivalences for Labelled Prime Event Structures built by Van Glabbeek and Goltz changes if we consider two simplified notions of event structures: the first is obtained by removing the causality relation (Coherence Spaces) and the second by removing the conflict relation (Elementary Event Structures). As expected, in both cases the spectrum turns out to be simplified, since some notions of equivalence coincide in the simplified settings; actually, we prove that removing causality simplifies the spectrum considerably more than removing conflict. Furthermore, while the labeling of events and their cardinality play no role when removing causality, both the labeling function and the cardinality of the event set dramatically influence the spectrum of equivalences in the conflict-free setting
A Logic for True Concurrency
We propose a logic for true concurrency whose formulae predicate about events
in computations and their causal dependencies. The induced logical equivalence
is hereditary history preserving bisimilarity, and fragments of the logic can
be identified which correspond to other true concurrent behavioural
equivalences in the literature: step, pomset and history preserving
bisimilarity. Standard Hennessy-Milner logic, and thus (interleaving)
bisimilarity, is also recovered as a fragment. We also propose an extension of
the logic with fixpoint operators, thus allowing to describe causal and
concurrency properties of infinite computations. We believe that this work
contributes to a rational presentation of the true concurrent spectrum and to a
deeper understanding of the relations between the involved behavioural
equivalences.Comment: 31 pages, a preliminary version appeared in CONCUR 201
Compositional Reasoning for Explicit Resource Management in Channel-Based Concurrency
We define a pi-calculus variant with a costed semantics where channels are
treated as resources that must explicitly be allocated before they are used and
can be deallocated when no longer required. We use a substructural type system
tracking permission transfer to construct coinductive proof techniques for
comparing behaviour and resource usage efficiency of concurrent processes. We
establish full abstraction results between our coinductive definitions and a
contextual behavioural preorder describing a notion of process efficiency
w.r.t. its management of resources. We also justify these definitions and
respective proof techniques through numerous examples and a case study
comparing two concurrent implementations of an extensible buffer.Comment: 51 pages, 7 figure
- …