Logic Programming with Linear Logic

Programming languages are the basic tools of computer science. The design of a good programming language is a trade-off between many factors. Perhaps the most important and difficult trade-off is between execution efficiency and programmer efficiency. Higher level languages reduce the amount of work the programmer has to do; however they have, to date, been less efficient than lower level languages. That lower level languages are necessarily more efficient is a piece of folklore which is under attack – higher level languages are constantly coming closer to the performance of the lower level languages. A consequence of this constantly closing performance gap is that the abstraction level of programming languages is slowly but inevitably rising. A class of programming languages which has been described as “very high level” is declarative programming languages. Declarative programming languages have simple formal semantics and are easier to reason about and to construct tools for than more traditional programming languages. However these languages do suffer from a number of problems. They are weak at expressing side effects and concurrency. Side effects are generally used to perform I/O and as a result declarative languages have been weak at expressing I/O. Declarative languages are also weak at expressing concurrency without compromising their semantic purity and as a result tend to be weak at expressing graphical user interfaces. Girard’s linear logic promises solutions to some of these problems – linear logic is capable of modelling updates, it has inspired linear types which enable side effects to be safely introduced for efficiency reasons, and linear logic can model concurrent behavior cleanly. This thesis focuses on the derivation of a logic programming language based on lin-

[1]  Simon J. E. Taylor,et al.  Status of the Mercury system , 1996 .

[2]  Jawahar Chirimar,et al.  Proof theoretic approach to specification languages , 1995 .

[3]  Natarajan Shankar,et al.  Proof search in first-order linear logic and other cut-free sequent calculi , 1994, Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science.

[4]  David Scott Warren.  Programming the PTQ Grammar in XSB , 1993, Workshop on Programming with Logic Databases , ILPS.

[5]  Roy Dyckhoff,et al.  Contraction-free sequent calculi for intuitionistic logic , 1992, Journal of Symbolic Logic.

[6]  Akinori Yonezawa,et al.  ACL - A Concurrent Linear Logic Programming Paradigm , 1993, ILPS.

[7]  John W. Lloyd,et al.  Combining Functional and Logic Programming Languages , 1994, ILPS.

[8]  Dale Miller,et al.  A Logical Analysis of Modules in Logic Programming , 1989, J. Log. Program..

[9]  Michael Winikoff,et al.  Programming in Lygon: A Brief Overview , 1995, ILPS.

[10]  Akinori Yonezawa,et al.  Static Analysis of Communication for Asynchronous Concurrent Programming Languages , 1995, SAS.

[11]  Michael Winikoff,et al.  Programming in Lygon: A System Demonstration , 1996, AMAST.

[12]  Catuscia Palamidessi,et al.  Encoding Transition Systems in Sequent Calculus , 2003, Linear Logic Tokyo Meeting.

[13]  Torben Bra,et al.  Introduction to Linear Logic , 1996 .

[14]  K. Fuchi,et al.  Concurrent Prolog , 1988 .

[15]  Michael Winikoff James Harland.  Implementation and development Issues for the Linear Logic Programming Language Lygon , 1995 .

[16]  J. S. Hodas.  Logic programming in intuitionistic linear logic: theory, design, and implementation , 1995 .

[17]  Jean-Marc Andreoli,et al.  LO and behold! Concurrent structured processes , 1990, OOPSLA/ECOOP '90.

[18]  James Harland,et al.  A Uniform Proof-Theoretic Investigation of Linear Logic Programming , 1994, J. Log. Comput..

[19]  Richard A. O'Keefe,et al.  The Craft of Prolog , 1990 .

[20]  Fergus Henderson,et al.  Logic Programming for the Real World , 1995 .

[21]  Ian Mackie,et al.  Lilac: a functional programming language based on linear logic , 1994, Journal of Functional Programming.

[22]  Dale Miller,et al.  Logic programming in a fragment of intuitionistic linear logic , 1991, [1991] Proceedings Sixth Annual IEEE Symposium on Logic in Computer Science.

[23]  Henry G. Baker.  Sparse polynomials and linear logic , 1993, SIGS.

[24]  Henry G. Baker.  A “linear logic” Quicksort , 1994, SIGP.

[25]  Erik Barendsen,et al.  Conventional and Uniqueness Typing in Graph Rewrite Systems , 1993, FSTTCS.

[26]  Jean-Marc Andreoli,et al.  Linear objects: Logical processes with built-in inheritance , 1990, New Generation Computing.

[27]  Michael Winikoff,et al.  Programming in Lygon: An Overview , 1996, AMAST.

[28]  Gopalan Nadathur,et al.  Uniform Proofs and Disjunctive Logic Programming (Extended Abstract) , 1995, LICS 1995.

[29]  Henry G. Baker,et al.  Lively linear Lisp: “look ma, no garbage!” , 1992, SIGP.

[30]  Michael Winikoff,et al.  Hitch Hiker's Guide to Lygon 0.7 , 1996 .

[31]  Iliano Cervesato.  Lollipops Taste of Vanilla too , 1994, ICLP Workshop: Proof-Theoretical Extensions on Logic Programming.

[32]  Pieter H. Hartel,et al.  Benchmarking implementations of lazy functional languages , 1993, FPCA '93.

[33]  Andre Scedrov,et al.  Linear Logic and Computation: A Survey , 1995 .

[34]  Dale Miller.  The pi-Calculus as a Theory in Linear Logic: Preliminary Results , 1992, ELP.

[35]  Edoardo Biagioni.  A structured TCP in standard ML. , 1994, SIGCOMM 1994.

[36]  John Hughes,et al.  Why Functional Programming Matters , 1989, Comput. J..

[37]  Graham Hutton,et al.  Higher-order functions for parsing , 1992, Journal of Functional Programming.

[38]  Gerhard Gentzen,et al.  Investigations into Logical Deduction , 1970 .

[39]  Joxan Jaffar,et al.  Constraint logic programming , 1987, POPL '87.

[40]  Naoyuki Tamura,et al.  Extension of WAM for a linear logic programming language , 2007 .

[41]  Frank Pfenning,et al.  Efficient Resource Management for Linear Logic Proof Search , 1996, ELP.

[42]  Jean-Yves Girard,et al.  Linear Logic and Lazy Computation , 1987, TAPSOFT, Vol.2.

[43]  Dale Miller,et al.  Logic Programming in a Fragment of Intuitionistic Linear Logic , 1994, Inf. Comput..

[44]  Paolo Volpe,et al.  Concurrent Logic Programming as Uniform Linear Proofs , 1994, ALP.

[45]  Pieter H. Hartel.  Benchmarking implementations of lazy functional languages II -- Two years later , 1995 .

[46]  Alexey P. Kopylov.  Decidability of linear affine logic , 1995, Proceedings of Tenth Annual IEEE Symposium on Logic in Computer Science.

[47]  Jean-Marc Andreoli,et al.  Interaction abstract machines , 1993 .

[48]  Paolo Ciancarini,et al.  Exploring the Coordination Space with LO , 1994 .

[49]  Jacqueline Vauzeilles,et al.  Generating Plans in Linear Logic , 1990, FSTTCS.

[50]  Jacqueline Vauzeilles,et al.  Generating Plans in Linear Logic I. Actions as Proofs , 1993, Theor. Comput. Sci..

[51]  M. Masseron,et al.  Generating Plans in Linear Logic I. A Geometry of Conjunctive Actions , 1993, Theor. Comput. Sci..

[52]  Matthew M. Huntbach,et al.  Programming In Concurrent Logic Languages , 1995, IEEE Softw..

[53]  Carl A. Gunter,et al.  Proving memory management invariants for a language based on linear logic , 1992, LFP '92.

[54]  Andre Scedrov,et al.  A brief guide to linear logic , 1990, Bull. EATCS.

[55]  Jean-Marc Andreoli,et al.  Communication as fair distribution of knowledge , 1991, Conference on Object-Oriented Programming Systems, Languages, and Applications.

[56]  S. C. Kleene,et al.  Introduction to Metamathematics , 1952 .

[57]  A. W. Bollen.  Relevant logic programming , 2005, Journal of Automated Reasoning.

[58]  Henri E. Bal,et al.  Programming languages for distributed computing systems , 1989, CSUR.

[59]  Philip Wadler,et al.  Comprehending monads , 1990, LISP and Functional Programming.

[60]  Nicholas Carriero,et al.  How to write parallel programs: a guide to the perplexed , 1989, CSUR.

[61]  James Harland,et al.  The aditi deductive database system , 1994, The VLDB Journal.

[62]  Tanel Tammet,et al.  Proof search strategies in linear logic , 1993 .

[63]  Ehud Shapiro,et al.  The family of concurrent logic programming languages , 1989, CSUR.

[64]  Drew McDermott,et al.  Nonmonotonic Logic and Temporal Projection , 1987, Artif. Intell..

[65]  Giorgio Delzanno,et al.  Objects in Forum , 1995, ILPS.

[66]  N. Kobayashi,et al.  Typed Higher-Order Concurrent Linear Logic Programming , 1994 .

[67]  Wanli Ma,et al.  An Overview of Temporal and Modal Logic Programming , 1994, ICTL.

[68]  Natarajan Shankar,et al.  Linearizing Intuitionistic Implication , 1993, Ann. Pure Appl. Log..

[69]  Henry G. Baker,et al.  Linear logic and permutation stacks—the Forth shall be first , 1994, CARN.

[70]  Michael Maher.  Resource Management Method for a Compiler System of a Linear Logic Programming Language , 1996 .

[71]  James Harland.  Some Applications of the Linear Logic Programming Language Lygon , 1996 .

[72]  Jean-Yves Girard.  Logic and Exceptions: A Few Remarks , 1992, J. Log. Comput..

[73]  Samson Abramsky,et al.  Computational Interpretations of Linear Logic , 1993, Theor. Comput. Sci..

[74]  Alessio Guglielmi,et al.  Concurrency and Plan Generation in a Logic Programming Language with a Sequential Operator , 1994, ICLP.

[75]  Matthew M. Huntbach.  An Introduction to RGDC as a Concurrent Object-Oriented Language , 1995, J. Object Oriented Program..

[76]  Colin Runciman,et al.  Linearity and Laziness , 1991, FPCA.

[77]  Michael Winikoff,et al.  Deterministic Resource Management for the Linear Logic Programming Language Lygon , 1994 .

[78]  John S. Boreczky.  Building common Lisp applications with reasonable performance , 1993 .

[79]  A. Momigliano.  Theorem Proving via Uniform Proofs , 1993 .

[80]  Ehud Shapiro,et al.  Algorithmic Program Debugging , 1983 .

[81]  Dale Miller,et al.  A multiple-conclusion meta-logic , 1994, Proceedings Ninth Annual IEEE Symposium on Logic in Computer Science.

[82]  L. Thorne McCarty,et al.  Adding Negation-as-Failure to Intuitionistic Logic Programming , 1990, NACLP.

[83]  Jean-Marc Andreoli,et al.  Abstract Interpretation of Linear Logic Programming , 1993, ILPS.

[84]  Frank Pfenning,et al.  Types in Logic Programming , 1992, ICLP.

[85]  Paul Hudak,et al.  Conception, evolution, and application of functional programming languages , 1989, CSUR.

[86]  Guy Perrier,et al.  On Proof Normalization in Linear Logic , 1992, Theor. Comput. Sci..

[87]  Colin Runciman,et al.  Applications Of Functional Programming , 1995 .

[88]  James Harland,et al.  On goal-directed provability in classical logic , 1993, Comput. Lang..

[89]  Gul A. Agha,et al.  Concurrent object-oriented programming , 1993, CACM.

[90]  James Harland,et al.  On hereditary Harrop formulae as a basis for logic programming , 1991 .

[91]  James Harland,et al.  On Normal Forms and Equivalence for Logic Programs , 1992, JICSLP.

[92]  Ian T. Foster,et al.  Strand: A Practical Parallel Programming Tool , 1989, NACLP.

[93]  Angelo Montanari,et al.  Modal Event Calculus in Lolli , 1994 .

[94]  James Harland.  A Proof-Theoretic Analysis of Goal-Directed Provability , 1994, J. Log. Comput..

[95]  Marek J. Sergot,et al.  A logic-based calculus of events , 1989, New Generation Computing.

[96]  Philip Wadler,et al.  The essence of functional programming (Invited talk) , 1997 .

[97]  Vladimir Alexiev,et al.  Applications of Linear Logic to Computation: An Overview , 1994, Log. J. IGPL.

[98]  Marko C. J. D. van Eekelen,et al.  Guaranteeing Safe Destructive Updates Through a Type System with Uniqueness Information for Graphs , 1993, Dagstuhl Seminar on Graph Transformations in Computer Science.

[99]  Jean-Yves Girard,et al.  Linear logic: its syntax and semantics , 1995 .

[100]  Vladimir Alexiev.  The Event Calculus as a Linear Logic Program , 1995 .

[101]  Gérard Berry,et al.  The chemical abstract machine , 1989, POPL '90.

[102]  Jean-Yves Girard,et al.  Linear Logic , 1987, Theor. Comput. Sci..

[103]  JEAN-MARC ANDREOLI,et al.  Logic Programming with Focusing Proofs in Linear Logic , 1992, J. Log. Comput..

[104]  Akinori Yonezawa,et al.  Type-theoretic foundations for concurrent object-oriented programing , 1994, OOPSLA 1994.

[105]  Erik Barendsen,et al.  Uniqueness Type Inference , 1995, PLILP.

[106]  Gopalan Nadathur,et al.  Hereditary Harrop Formulas and Uniform Proof Systems , 1987, Logic in Computer Science.

[107]  Gopalan Nadathur,et al.  Uniform Provability in Classical Logic , 1998, J. Log. Comput..

[108]  Lee Naish,et al.  Automating Control for Logic Programs , 1985, J. Log. Program..

[109]  Tanel Tammet,et al.  Completeness of Resolution for Definite Answers , 1995, J. Log. Comput..

[110]  Duncan C. Sinclair.  Solid Modelling in Haskell , 1990, Functional Programming.

[111]  Patrick Denis Lincoln.  Computational aspects of linear logic , 1992 .

[112]  Paul J. Krause,et al.  The art of Prolog - second edition by Leon Sterling and Ehud Shapiro, MIT Press, Cambridge, MA 1994, pp 509, £19.95 (paperback), £44.94 (hardback), ISBN 0-262-19338-8 , 1995, The Knowledge Engineering Review.

[113]  Greg Michaelson,et al.  Parallel Logic Programming in parlog: the Language and its Implementation by Steve Gregory: Published by Addison-Wesley, 217pp. £17.95 , 1988 .

[114]  Joshua S. Hodas,et al.  Specifying Filler-Gap Dependency Parsers in a Linear-Logic Programming Language , 1992, JICSLP.

[115]  Jeff Polakow,et al.  Forum as a Logic Programming Language , 1996, Electron. Notes Theor. Comput. Sci..

[116]  Nicholas Carriero,et al.  Linda in context , 1989, CACM.

[117]  Michael Winikoff,et al.  Implementing the Linear Logic Programming Language Lygon , 1995, ILPS.

[118]  Gopalan Nadathur,et al.  Uniform Proofs as a Foundation for Logic Programming , 1991, Ann. Pure Appl. Log..