Showing papers on "Linear logic published in 1994"

Games and full completeness for multiplicative linear logic

Abstract: We present a game semantics for Linear Logic, in which formulas denote games and proofs denote winning strategies. We show that our semantics yields a categorical model of Linear Logic and prove full completeness for Multiplicative Linear Logic with the MIX rule: every winning strategy is the denotation of a unique cut-free proof net. A key role is played by the notion of history-free strategy; strong connections are made between history-free strategies and the Geometry of Interaction. Our semantics incorporates a natural notion of polarity, leading to a refined treatment of the additives. We make comparisons with related work by Joyal, Blass, et al.

A Mixed Linear and Non-Linear Logic: Proofs, Terms and Models (Extended Abstract)

Abstract: Intuitionistic linear logic regains the expressive power of intuitionistic logic through the ! (‘of course’) modality. Benton, Bierman, Hyland and de Paiva have given a term assignment system for ILL and an associated notion of categorical model in which the ! modality is modelled by a comonad satisfying certain extra conditions. Ordinary intuitionistic logic is then modelled in a cartesian closed category which arises as a full subcategory of the category of coalgebras for the comonad.

A multiple-conclusion meta-logic

Abstract: The theory of cut-free sequent proofs has been used to motivate and justify the design of a number of logic programming languages. Two such languages, /spl lambda/Prolog and its linear logic refinement, Lolli (J. Hodas and D. Miller, 1994), provide for various forms of abstraction (modules, abstract data types, higher-order programming) but lack primitives for concurrency. The logic programming language, LO (Linear Objects) (J. Andreoli and R. Pareschi, 1991) provides for concurrency but lacks abstraction mechanisms. We present Forum, a logic programming presentation of all of linear logic that modularly extends the languages /spl lambda/Prolog, Lolli, and LO. Forum, therefore, allows specifications to incorporate both abstractions and concurrency. As a meta-language, Forum greatly extends the expressiveness of these other logic programming languages. To illustrate its expressive strength, we specify in Forum a sequent calculus proof system and the operational semantics of a functional programming language that incorporates such nonfunctional features as counters and references. >

A Uniform Proof-theoretic Investigation of Linear Logic Programming

Abstract: In this paper we consider the problem of identifying logic programming languages for linear logic. Our analysis builds on a notion of goal-directed provability, characterized by the so-called uniform proofs, previously introduced for minimal and intuitionistic logic. A class of uniform proofs in linear logic is identiied by an analysis of the permutability of inferences in the linear sequent calculus. We show that this class of proofs is complete (for logical consequence) for a certain (quite large) fragment of linear logic, which thus forms a logic programming language. We obtain a notion of resolution proof, in which only one left rule, of clause-directed resolution, is required. We also consider a translation, resembling those of Girard, of the hereditary Harrop fragment of intuitionistic logic into our framework. We show that goal-directed provability is preserved under this translation.

Chu Spaces : A Model for Concurrency

Abstract: A Chu space is a binary relation between two sets. In this thesis we show that Chu spaces form a non-interleaving model of concurrency which extends event structures while endowing them with an algebraic structure whose natural logic is linear logic. We provide several equivalent definitions of Chu spaces, including two pictorial representations. Chu spaces represent processes as automata or schedules, and Chu duality gives a simple way of converting between schedules and automata. We show that Chu spaces can represent various concurrency concepts like conflict, temporal precedence and internal and external choice, and they distinguish between causing and enabling events. We present a process algebra for Chu spaces including the standard combinators like parallel composition, sequential composition, choice, interaction, restriction, and show that the various operational identities between these hold for Chu spaces. The solution of recursive domain equations is possible for most of these operations, giving us an expressive specification and programming language. We define a history preserving equivalence between Chu spaces, and show that it preserves the causal structure of a process.

Lambek calculus and its relational semantics: Completeness and incompleteness

Abstract: The problem of whether Lambek Calculus is complete with respect to (w.r.t.) relational semantics, has been raised several times, cf. van Benthem (1989a) and van Benthem (1991). In this paper, we show that the answer is in the affirmative. More precisely, we will prove that that version of the Lambek Calculus which does not use the empty sequence is strongly complete w.r.t. those relational Kripke-models where the set of possible worlds,W, is a transitive binary relation, while that version of the Lambek Calculus where we admit the empty sequence as the antecedent of a sequent is strongly complete w.r.t. those relational models whereW=U×U for some setU. We will also look into extendability of this completeness result to various fragments of Girard's Linear Logic as suggested in van Benthem (1991), p. 235, and investigate the connection between the Lambek Calculus and language models.

A generalization of analytic deduction via labelled deductive systems. Part I: Basic substructural logics

Abstract: In this series of papers we set out to generalize the notion of classical analytic deduction (i.e., deduction via elimination rules) by combining the methodology of labelled deductive systems (LDS) with the classical systemKE. LDS is a unifying framework for the study of logics and of their interactions. In the LDS approach the basic units of logical derivation are not just formulae butlabelled formulae, where the labels belong to a given “labelling algebra”. The derivation rules act on the labels as well as on the formulae, according to certain fixed rules of propagation. By virtue of the extra power of the labelling algebras, standard (classical or intuitionistic) proof systems can be extended to cover a much wider territory without modifying their structure. The systemKE is a new tree method for classical analytic deduction based on “analytic cut”.KE is a refutation system, like analytic tableaux and resolution, but it is essentially more efficient than tableaux and, unlike resolution, does not require any reduction to normal form. We start our investigation with the family of substructural logics. These are logical systems (such as Lambek's calculus, Anderson and Belnap's relevance logic, and Girard's linear logic) which arise from disallowing some or all of the usual structural properties of the notion of logical consequence. This extension of traditional logic yields a subtle analysis of the logical operators which is more in tune with the needs of applications. In this paper we generalize the classicalKE system via the LDS methodology to provide a uniform refutation system for the family of substructural logics. The main features of this generalized method are the following: (a) each logic in the family is associated with a “labelling algebra”; (b) the tree-expansion rules (for labelled formulae) are the same for all the logics in the family; (c) the difference between one logic and the other is captured by the conditions under which a branch is declared closed; (d) such conditions depend only on the labelling algebra associated with each logic; and (e) classical and intuitionistic negations are characterized uniformly, by means of the same tree-expansion rules, and their difference is reduced to a difference in the labelling algebra used in closing a branch. In this first part we lay the theoretical foundations of our method. In the second part we shall continue our investigation of substructural logics and discuss the algorithmic aspects of our approach.

Proof strategies in linear logic

Abstract: Linear logic, introduced by J.-Y. Girard, is a refinement of classical logic providing means for controlling the allocation of “resources”. It has aroused considerable interest from both proof theorists and computer scientists. In this paper we investigate methods for automated theorem proving in propositional linear logic. Both the “bottom-up” (tableaux) and “top-down” (resolution) proof strategies are analyzed. Various modifications of sequent rules and efficient search strategies are presented along with the experiments performed with the implemented theorem provers.

Linear logic, totality and full completeness

Abstract: I give a 'totality space' model for linear logic [4] derived by taking an abstract view of computations on a datatype. The model has similarities with both the coherence space model and game-theoretic models, but is based upon a notion of total object. Using this model, I prove a full completeness result. In other words, I show that the mapping of proofs to their interpretations (here collections of total objects uniform for a given functor) in the model is a surjection. >

Applications of Linear Logic to Computation: An Overview

Abstract: 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 references of which some are about applications of LL

A Deductive Account of Quantification in LFG.

Abstract: The relationship between Lexical-Functional Grammar (LFG) functional structures (f-structures) for sentences and their semantic interpretations can be expressed directly in a fragment of linear logic in a way that explains correctly the constrained interactions between quantifier scope ambiguity and bound anaphora. The use of a deductive framework to account for the compositional properties of quantifying expressions in natural language obviates the need for additional mechanisms, such as Cooper storage, to represent the different scopes that a quantifier might take. Instead, the semantic contribution of a quantifier is recorded as an ordinary logical formula, one whose use in a proof will establish the scope of the quantifier. The properties of linear logic ensure that each quantifier is scoped exactly once. Our analysis of quantifier scope can be seen as a recasting of Pereira's analysis (Pereira, 1991), which was expressed in higher-order intuitionistic logic. But our use of LFG and linear logic provides a much more direct and computationally more flexible interpretation mechanism for at least the same range of phenomena. We have developed a preliminary Prolog implementation of the linear deductions described in this work.

Higher-Order Concurrent Linear Logic Programming

Abstract: We propose a typed, higher-order, concurrent linear logic programming called higher-order ACL, which uniformly integrates a variety of mechanisms for concurrent computation based on asynchronous message passing. Higher-order ACL is based on a proof search paradigm according to the principle, proofs as computations, formulas as processes in linear logic. In higher-order ACL, processes as well as functions, and other values can be communicated via messages, which provides high modularity of concurrent programs. Higher-order ACL can be viewed as an asynchronous counterpart of Milner's higher-order, polyadic π-calculus. Moreover, higher-order ACL is equipped with an elegant ML-style type system that ensures (1) well typed programs can never cause type mismatch errors, and (2) there is a type inference algorithm which computes a most general typing for an untyped term. We also demonstrate a power of higher-order ACL by showing several examples of “higher-order concurrent programming.”

Structural Cut Elimination in Linear Logic.

Abstract: : We present a new proof of cut elimination for linear logic which proceeds by three nested structural inductions, avoiding the explicit use of multi-sets and termination measures on sequent derivations. The computational content of this proof is a non-deterministic algorithm for cut elimination which is amenable to an elegant implementation in Elf. We show this implementation in detail. (AN)

An Internal Language for Autonomous Categories

Abstract: In this extended abstract we present an internal language for symmetric monoidal closed (autonomous) categories analogous to the typed lambda calculus being an internal language for cartesian closed categories. The language we propose is the term assignment to the multiplicative fragment of Intuitionistic Linear Logic, which possesses exactly the right structure for an autonomous theory. We prove that this language is an internal language and show as an application the coherence theorem of Kelly and Mac Lane, which becomes straightforward to state and prove. We then hint at some further applications of this language; a further treatment will be given in the full paper.

The conjoinability relation in Lambek calculus and linear logic

Abstract: In 1958 J. Lambek introduced a calculusL of syntactic types and defined an equivalence relation on types: “x≡ y means that there exists a sequence x=x1,...,xn=y (n ≥ 1), such thatx i →x i+1 or xi+ →x i (1 ≤i ≤ n)”. He pointed out thatx ≡y if and only if there is joinz such thatx →z andy →z. This paper gives an effective characterization of this equivalence for the Lambeck calculiL andLP, and for the multiplicative fragments of Girard's and Yetter's linear logics. Moreover, for the non-directed Lambek calculusLP and the multiplicative fragment of Girard's linear logic, we present linear time algorithms deciding whether two types are equal, and finding a join for them if they are.

The Girard Translation Extended with Recursion

Abstract: This paper extends Curry-Howard interpretations of Intuitionistic Logic and Intuitionistic Linear Logic rules for recursion. The resulting term languages, the λrec-calculus and the linear λrec-calculus respectively, are given sound categorical interpretations. The embedding of proofs of Intuitionistic Logic into proofs of Intuitionistic Linear Logic given by the Girard Translation is extended with the rules for recursion such that an embedding of terms of the λrec-calculus into terms of the linear λrec-calculus is induced via the extended Curry-Howard isomorphisms. This embedding is shown to be sound with respect to the categorical interpretations.

Passivity and independence

Abstract: Most programming languages have certain phrases (like expressions) which only read information from the state and certain others (like commands) which write information to the state. These are called passive and active phrases respectively. Semantic models which make these distinctions have been hard to find. For instance, most semantic models have expression denotations that (temporarily) change the state. Common reasoning principles, such as the Hoare's assignment axiom, are not valid in such models. We define here a semantic model which captures the notions of "change", "absence of change" and "independent change" etc. This is done by extending the author's "linear logic model of state" with dependence/independence relations so that sequential traces give way to pomset traces. >

Cut-property and negation as failure

Abstract: What is the semantics of Negation-as-Failure in logic programming? We try to answer this question by proof-theoretic methods. A rule based sequent calculus is used in which a sequent is provable if, and only if, it is true in all three-valued models of the completion of a logic program. The main theorem is that proofs in the sequent calculus can be transformed into SLDNF-computations if, and only if, a program has the cut-property. A fragment of the sequent calculus leads to a sound and complete semantics for SLDNF-resolution with substitutions. It turns out that this version of SLDNF-resolution is sound and complete with respect to three-valued possible world models of the completion for arbitrary logic programs and arbitrary goals. Since we are dealing with possibly nonterminating computations and constructive proofs, three-valued possible world models seem to be an appropriate semantics.

Foundations of Proof Search Strategies Design in Linear Logic

Abstract: In this paper, we investigate automated proof construction in classical linear logic (CLL) by giving logical foundations for the design of proof search strategies. We propose common theoretical foundations for top-down, bottom-up and mixed proof search procedures with a systematic formalization of strategies construction using the notions of immediate or chaining composition or decomposition, deduced from permutability properties and inference movements in a proof. Thus, we have logical bases for the design of proof strategies in CLL fragments and then we can propose sketches for their design.

A modal view of linear logic

Abstract: We present a sequent calculus for the modal logic S4, and building on some relevant features of this system (the absence of contraction rules and the confinement of weakenings into axioms and modal rules) we show how S4 can easily be translated into full prepositional linear logic, extending the Grishin-Ono translation of classical logic into linear logic. The translation introduces linear modalities (exponentials) only in correspondence with S4 modalities. We discuss the complexity of the decision problem for several classes of linear formulas naturally arising from the proposed translations.

Bistructures, Bidomains and Linear Logic

Abstract: Bistructures are a generalisation of event structures which allow a representation of spaces of functions at higher types in an orderextensional setting The partial order of causal dependency is replaced by two orders, one associated with input and the other with output in the behaviour of functions Bistructures form a categorical model of Girard's classical linear logic in which the involution of linear logic is modelled, roughly speaking, by a reversal of the roles of input and output The comonad of the model has an associated co-Kleisli category which is closely related to that of Berry's bidomains (both have equivalent non-trivial full sub-cartesian closed categories)

Petri Nets, Horn Programs, Linear Logic, and Vector Games

Abstract: Linear Logic was introduced by Girard as a resource-sensitive refinement of classical logic. Linear Logic is of considerable interest for Computer Science. In this paper we focus on the correlations between natural fragments of Linear Logic and a number of basic concepts related to different branches of Computer Science such as Concurrency Theory, Theory of Computations, Horn Programming, and Game Theory. In particular, such a complete correspondence allows us to introduce several new semantics for Linear Logic and to clarify many results on the complexity of natural fragments of Linear Logic.

Linear logic and permutation stacks—the Forth shall be first

Abstract: Girard's linear logic can be used to model programming languages in which each bound variable name has exactly one "occurrence"---i.e., no variable can have implicit "fan-out"; multiple uses require explicit duplication. Among other nice properties, "linear" languages need no garbage collector, yet have no dangling reference problems. We show a natural equivalence between a "linear" programming language and a stack machine in which the top items can undergo arbitrary permutations. Such permutation stack machines can be considered combinator abstractions of Moore's Forth programming language.