Linear logic, introduced by Girard, is a refinement of classical logic with a natural, intrinsic accounting of resources. We show that unlike most other propositional (quantifier-free) logics, full propositional linear logic is undecidable. Further, we prove that without the modal storage operator, which indicates unboundedness of resources, the decision problem becomes pspace-complete. We also establish membership in np for the multiplicative fragment, np-completeness for the multiplicative fragment extended with unrestricted weakening, and undecidability for certain fragments of noncommutative propositional linear logic. 1 Introduction Linear logic, introduced by Girard [14, 18, 17], is a refinement of classical logic which may be derived from a Gentzen-style sequent calculus axiomatization of classical logic in three steps. The resulting sequent system Lincoln@CS.Stanford.EDU Department of Computer Science, Stanford University, Stanford, CA 94305, and the Computer Science Labo...

An overview of linear logic is given, including an extensive bibliography and a simple example of the close relationship between linear logic and computation.

This paper is an overview of existing applications of Linear Logic (LL) to issues of computation. After a substantial introduction to LL, it discusses the implications of LL to functional programming, logic programming, concurrent and object-oriented programming and some other applications of LL, like semantics of negation in LP, non-monotonic issues in AI planning, etc. Although the overview covers pretty much the state-of-the-art in this area, by necessity many of the works are only mentioned and referenced, but not discussed in any considerable detail. The paper does not presuppose any previous exposition to LL, and is addressed more to computer scientists (probably with a theoretical inclination) than to logicians. The paper contains over 140 references, of which some 80 are about applications of LL. 1 Linear Logic Linear Logic (LL) was introduced in 1987 by Girard [62]. From the very beginning it was recognized as relevant to issues of computation (especially concurrency and stat...

We present a very simple and powerful framework for indeterminate, asynchronous, higher-order computation based on the formula-as-agent and proof-ascomputation interpretation of (higher-order) linear logic [Gir87]. The framework significantly refines and extends the scope of the concurrent constraint programming paradigm [Sar89] in two fundamental ways: (1) by allowing for the consumption of information by agents it permits a direct modelling of (indeterminate) state change in a logical framework, and (2) by admitting simply-typed -terms as dataobjects, it permits the construction, transmission and application of (abstractions of) programs at run-time. Much more dramatically, however, the framework can be seen as presenting higher-order (and if desired, constraint-enriched) versions of a variety of other asynchronous concurrent systems, including the asynchronous ("input guarded") fragment of the (first-order) ß-calculus, Hewitt's actors formalism, (abstract forms of) Gelernter's Lin...

this paper we will restrict attention to propositional linear logic. The sequent calculus notation, due to Gentzen [10], uses roman letters for propositions, and greek letters for sequences of formulas. A sequent is composed of two sequences of formulas separated by a `, or turnstile symbol. One may read the sequent \Delta ` \Gamma as asserting that the multiplicative conjunction of the formulas in \Delta together imply the multiplicative disjunction of the formulas in \Gamma. A sequent calculus proof rule consists of a set of hypothesis sequents, displayed above a horizontal line, and a single conclusion sequent, displayed below the line, as below: Hypothesis1 Hypothesis2 Conclusion 4 Connections to Other Logics

Introduction There are many interesting fragments of linear logic worthy of study in their own right, most described by the connectives which they employ. Full linear logic includes all the logical connectives, which come in three dual pairs: the exponentials ! and ?, the additives & and \Phi, and the multiplicatives\Omega and . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ........ . SRI International Computer Science Laboratory, Menlo Park CA 94025 USA. Work supported under NSF Grant CCR-9224858. lincoln@csl.sri.com http://www.csl.sri.com/lincoln/lincoln.html Patrick Lincoln For the most part we will consider fragments of linear logic built up using these connectives in any combination. For example, full linear logic formulas may employ any connective, while multiplic

Abstract. A long standing problem in logic programming is how to impose directionality on programs in a safe fashion. The benefits of directionality include freedom from explicit sequential control, the ability to reason about algorithmic properties of programs (such as termination, complexity and deadlock-freedom) and controlling concurrency. By using Girard’s linear logic, we are able to devise a type system that combines types and modes into a unified framework, and enables one to express directionality declaratively. The rich power of the type system allows outputs to be embedded in inputs and vice versa. Type checking guarantees that values have unique producers, but multiple consumers are still possible. From a theoretical point of view, this work provides a “logic programming interpretation ” of (the proofs of) linear logic, adding to the concurrency and functional programming interpretations that are already known. It also brings logic programming into the broader world of typed languages and types-as-propositions paradigm, enriching it with static scoping and higher-order features.

Real-time finite-state systems may be specified in linear logic by means of linear implications between conjunctions of fixed finite length. In this setting, where time is treated as a dense linear ordering, safety properties may be expressed as certain provability problems. These provability problems are shown to be in pspace. They are solvable, with some guidance, by finite proof search in concurrent logic programming environments based on linear logic and acting as sort of model-checkers. One advantage of our approach is that either it provides unsafe runs or it actually establishes safety. 1 Introduction There are a number of formalisms for expressing real-time processes, including [1, 6, 7, 3, 4, 5, 50, 44, 45, 38]. Many of these real-time formalisms are based on temporal logic or its variations [46, 38, 33] or on timed process algebras [14, 42, 43, 23, 12], or on Buchi automata [52, 3]. In some cases exact complexity-theoretic information is available, such as [51, 3, 5], while ...

Rewriting logic is proposed as a logic of concurrent action and change that solves the frame problem and that subsumes and unifies a number of previous logics of change, including linear logic and Horn logic with equality. Rewriting logic can represent action and change with great flexibility and generality; this flexibility is illustrated by many examples, including examples that show how concurrent object-oriented systems are naturally represented. In addition, rewriting logic has a simple formalism, with only a few rules of deduction; it supports user-definable logical connectives, which can be chosen to fit the problem at hand; it is intrinsically concurrent; and it is realizable in a wide spectrum logical language (Maude and its MaudeLog extension) supporting executable specification and programming. Contents 1 Introduction 2 1.1 What the frame problem (in our sense) is . . . . . . . . . . . . . . . . . . . . . . . 2 1.2 What the frame problem (in our sense) is not . . . . . . ....

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).