Reference counting as a computational interpretation of linear logic

We develop formal methods for reasoning about memory usage at a level of abstraction suitable for establishing or refuting claims about the potential applications of linear logic for static analysis. In particular, we demonstrate a precise relationship between type correctness for a language based on linear logic and the correctness of a reference-counting interpretation of the primitives that the language draws from the rules for the `of course' operation. Our semantics is `low-level' enough to express sharing and copying while still being `highlevel' enough to abstract away from details of memory layout. This enables the formulation and proof of a result describing the possible run-time reference counts of values of linear type.

[1]  Philip Wadler,et al.  Is there a use for linear logic? , 1991, PEPM '91.

[2]  Paul Hudak,et al.  Single-threaded polymorphic lambda calculus , 1990, [1990] Proceedings. Fifth Annual IEEE Symposium on Logic in Computer Science.

[3]  Benjamin Goldberg,et al.  Polymorphic type reconstruction for garbage collection without tags , 1992, LFP '92.

[4]  Peter W. O'Hearn.  Linear Logic and Interference Control , 1991, Category Theory and Computer Science.

[5]  S. Purushothaman Iyer,et al.  An Adequate Operational Semantics for Sharing in Lazy Evaluation , 1992, ESOP.

[6]  Mitchell Wand,et al.  Proving the correctness of storage representations , 1992, LFP '92.

[7]  Valeria C V de Paiva,et al.  Term Assignment for Intuitionistic Linear Logic , 1992 .

[8]  Nick Benton,et al.  A Term Calculus for Intuitionistic Linear Logic , 1993, TLCA.

[9]  Robin Milner,et al.  Definition of standard ML , 1990 .

[10]  Olivier Danvy,et al.  Separating stages in the continuation-passing style transformation , 1993, POPL '93.

[11]  William A. Howard,et al.  The formulae-as-types notion of construction , 1969 .

[12]  G. Winskel.  The formal semantics of programming languages , 1993 .

[13]  Philip Wadler,et al.  Linear Types can Change the World! , 1990, Programming Concepts and Methods.

[14]  S. L. Graham,et al.  List Processing in Real Time on a Serial Computer , 1978 .

[15]  Werner Kluge,et al.  Implementation of Functional Languages , 1996, Lecture Notes in Computer Science.

[16]  Andrzej Filinski.  Linear continuations , 1992, POPL '92.

[17]  Val Tannen,et al.  Computing with coercions , 1990, LISP and Functional Programming.

[18]  Philip Wadler,et al.  There's No Substitute for Linear Logic , 1991 .

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

[20]  P. Lincoln,et al.  Operational aspects of linear lambda calculus , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

[21]  Yves Lafont,et al.  The Linear Abstract Machine , 1988, Theor. Comput. Sci..

[22]  Paul Hudak.  A semantic model of reference counting and its abstraction (detailed summary) , 1986, LFP '86.

[23]  Patrick Lincoln,et al.  Linear logic , 1992, SIGA.

[24]  Chris Hankin,et al.  Abstract Interpretation of Declarative Languages , 1987 .

[25]  Robin Milner,et al.  Commentary on standard ML , 1990 .

[26]  Daniel G. Bobrow,et al.  An efficient, incremental, automatic garbage collector , 1976, CACM.

[27]  J. Girard,et al.  Proofs and types , 1989 .

[28]  Jon L. White.  Proceedings of the 1992 ACM conference on LISP and functional programming , 1992 .

[29]  Andrew W. Appel,et al.  Compiling with Continuations , 1991 .

[30]  Carl A. Gunter.  Semantics of programming languages: structures and techniques , 1993, Choice Reviews Online.

[31]  Gilles Kahn,et al.  Natural Semantics , 1987, STACS.

[32]  Henry G. Baker,et al.  List processing in real time on a serial computer , 1978, CACM.

[33]  George E. Collins,et al.  A method for overlapping and erasure of lists , 1960, CACM.

[34]  Joëlle Despeyroux,et al.  Proof of Translation in Natural Semantics , 1986, LICS.

[35]  Dana S. Scott,et al.  A Type-Theoretical Alternative to ISWIM, CUCH, OWHY , 1993, Theor. Comput. Sci..

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

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

[38]  Richard P. Gabriel,et al.  Performance and evaluation of Lisp systems , 1985 .

[39]  Gordon D. Plotkin,et al.  Call-by-Name, Call-by-Value and the lambda-Calculus , 1975, Theor. Comput. Sci..

[40]  G.D. Plotkin,et al.  LCF Considered as a Programming Language , 1977, Theor. Comput. Sci..

[41]  J. Roger Hindley,et al.  To H.B. Curry: Essays on Combinatory Logic, Lambda Calculus, and Formalism , 1980 .

[42]  WadlerPhilip.  Is there a use for linear logic , 1991 .

[43]  John Launchbury,et al.  A natural semantics for lazy evaluation , 1993, POPL '93.