The Concurrent Logical Framework, or CLF, is a new logical framework in which concurrent computations can be represented as monadic objects, for which there is an intrinsic notion of concurrency. It is designed as a conservative extension of the linear logical framework LLF with the synchronous connectives# of intuitionistic linear logic, encapsulated in a monad. LLF is itself a conservative extension of LF with the asynchronous connectives -#, & and #.

1.1 Quantification and the subformula property.................. 3 1.2 Ground forward sequent calculus......................... 5 1.3 Lifting to free variables............................... 10

We present a new logic, Linc, which is designed to be used as a framework for specifying and reasoning about operational semantics. Linc is an extension of firstorder intuitionistic logic with a proof theoretic notion of definitions, induction and coinduction, and a new quantifier #.

We present the propositional fragment CLF0 of the Concurrent Logical Framework (CLF). CLF extends the Linear Logical Framework to allow the natural representation of concurrent computations in an object language. The underlying type theory uses monadic types to segregate values from computations. This separation leads to a tractable notion of definitional equality that identifies computations di#ering only in the order of execution of independent steps. From a logical point of view our type theory can be seen as a novel combination of lax logic and dual intuitionistic linear logic. An encoding of a small Petri net exemplifies the representation methodology, which can be summarized as "concurrent computations as monadic expressions ".

The logical framework LF is a constructive type theory of dependent functions that can elegantly encode many other logical systems. Prior work has studied the benefits of extending it to the linear logical framework LLF, for the incorporation linear logic features into the type theory affords good representations of state change. We describe and argue for the usefulness of an extension of LF by features inspired by hybrid logic, which has several benefits. For one, it shows how linear logic features can be decomposed into primitive operations manipulating abstract resource labels. More importantly, it makes it possible to realize a metalogical framework capable of reasoning about stateful deductive systems encoded in the style familiar from prior work with LLF, taking advantage of familiar methodologies used for metatheoretic reasoning in LF.Acknowledgments From the very first computer science course I took at CMU, Frank Pfenning has been an exceptional teacher and mentor. For his patience, breadth of knowledge, and mathematical good taste I am extremely thankful. No less do I owe to the other two major contributors to my programming languages

We introduce substructural operational semantics (SSOS), a presentation form for the semantics of programming languages. It combines ideas from structural operational semantics and type theories based on substructural logics (such as linear logic) in order to obtain a rich, uniform, and modular framework. We illustrate SSOS with a sequence of specifications, starting from a simple functional language presented in linear destination-passing style (LDPS). Next we show how to extend the first specification modularly (that is, by adding new rules for new constructs without changing earlier rules) to treat imperative and concurrent constructs. We briefly compare our means of achieving modularity with that of modular structural operational semantics [1] and contextual semantics [2]. We then discuss how structural properties of configurations (on which the operational semantics is defined) are related to structural properties of various forms of hypothetical judgments originating in the study of linear logic and type theory. Ordered, linear, affine, and unrestricted hypothetical judgments can be

We describe a substructural logic with ordered, linear, and persistent propositions and then endow a fragment with a committed choice forward-chaining operational interpretation. Exploiting higher-order terms in this metalanguage, we specify the operational semantics of a number of object language features, such as call-by-value, call-by-name, call-by-need, mutable store, parallelism, communication, exceptions and continuations. The specifications exhibit a high degree of uniformity and modularity that allows us to analyze the structural properties required for each feature in isolation. Our substructural framework thereby provides a new methodology for language specification that synthesizes structural operational semantics, abstract machines, and logical approaches. 1

This 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 to 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. In the second part of the paper, we propose a completely 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. 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, while the structural equivalence corresponds directly to logically-motivated structural properties of ω-multisets (with one exception).

Abstract. We present the theory and implementation of a theorem prover forfirst-order intuitionistic linear logic based on the inverse method. The central proof-theoretic insights underlying the prover concern resource management andfocused derivations, both of which are traditionally understood in the domain of backward reasoning systems such as logic programming. We illustrate how re-source management, focusing, and other intrinsic properties of linear connectives affect the basic forward operations of rule application, contraction, and forwardsubsumption. We also present some preliminary experimental results obtained with our implementation.

We present a revisited semantics for multiset rewriting founded on the left sequent rules of linear logic in its LV presentation. The resulting interpretation is extended with a majority of linear connectives into the language of #- multisets. It 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. The cut rules introduce finite auxiliary rewriting chains and are admissible. 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. A simple translation maps process constructors of the asynchronous #-calculus to rewrite operators, while the structural equivalence corresponds directly to logically-motivated structural properties of #-multisets (with one exception). 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. Additionally, its deep logical underpinning makes it an ideal common ground for systematically comparing protocol specification languages, a task currently done in an ad-hoc manner.