Interpreting Functions as Pi-Calculus Processes: A Tutorial

This paper is concerned with the relationship between-calculus and-calculus. The-calculus talks about functions and their applicative behaviour. This contrasts with the-calculus, that talks about processes and their interactive behaviour. Application is a special form of interaction , and therefore functions can be seen as a special form of processes. We study how the functions of the-calculus (the computable functions) can be represented as-calculus processes. The-calculus semantics of a language induces a notion of equality on the terms of that language. We therefore also analyse the equality among functions that is induced by their representation as-calculus processes. This paper is intended as a tutorial. It however contains some original contributions. The main ones are: the use of well-known Continuation Passing Style transforms to derive the encodings into-calculus and prove their correctness; the encoding of typed-calculi. Note: This is a draft of a chapter of a book that I am writing with David Walker. In the hope of making the paper self-contained, I have added appendices with background material on-calculus.

[1]  Jean-Jacques Lévy,et al.  An Algebraic Interpretation of the lambda beta K-Calculus; and an Application of a Labelled lambda -Calculus , 1976, Theor. Comput. Sci..

[2]  D. J. Walker,et al.  Bisimulation and Divergence , 1990, Inf. Comput..

[3]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[4]  Mario Tokoro,et al.  An Object Calculus for Asynchronous Communication , 1991, ECOOP.

[5]  J. Roger Hindley,et al.  Introduction to combinators and λ-calculus , 1986, Acta Applicandae Mathematicae.

[6]  Chetan R. Murthy.  A computational analysis of Girard's translation and LC , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

[7]  Olivier Danvy,et al.  Thunks and the λ-calculus , 1997, Journal of Functional Programming.

[8]  Davide Sangiorgi.  An Interpretation of Typed Objects into Typed pi-Calculus , 1998, Inf. Comput..

[9]  Robin Milner,et al.  Barbed Bisimulation , 1992, ICALP.

[10]  Joachim Niehren,et al.  Functional computation as concurrent computation , 1996, POPL '96.

[11]  Bent Thomsen,et al.  Calculi for higher order communicating systems , 1990 .

[12]  Douglas J. Howe.  Proving Congruence of Bisimulation in Functional Programming Languages , 1996, Inf. Comput..

[13]  Nobuko Yoshida,et al.  Optimal reduction in weak-λ-calculus with shared environments , 1993, FPCA '93.

[14]  Lone Leth.  Functional programs as reconfigurable networks of communicating processes , 1991 .

[15]  Albert R. Meyer,et al.  Continuation Semantics in Typed Lambda-Calculi (Summary) , 1985, Logic of Programs.

[16]  D. Sangiorgi.  - calculus , internal mobility , and agent-passing calculi , 1995 .

[17]  Michael J. Fischer,et al.  Lambda-calculus schemata , 1993, LISP Symb. Comput..

[18]  Martín Abadi,et al.  A Theory of Objects , 1996, Monographs in Computer Science.

[19]  Cosimo Laneve,et al.  - Calculus , Multiplicities and the-Calculus , 1995 .

[20]  Olivier Danvy,et al.  A generic account of continuation-passing styles , 1994, POPL '94.

[21]  Kohei Honda,et al.  Principal Typing Schemes in a Polyadic pi-Calculus , 1993, CONCUR.

[22]  Matthew Hennessy,et al.  Algebraic theory of processes , 1988, MIT Press series in the foundations of computing.

[23]  A. Meyer,et al.  Bisimulation can't be traced. Preliminary report , 1987 .

[24]  Christopher Strachey,et al.  Continuations: A Mathematical Semantics for Handling Full Jumps , 2000, High. Order Symb. Comput..

[25]  Simon Brock,et al.  Process Semantics of Graph Reduction , 1995, CONCUR.

[26]  H. Barendregt.  The type free lambda calculus , 1977 .

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

[28]  Peter Zilahy Ingerman,et al.  Thunks: a way of compiling procedure statements with some comments on procedure declarations , 1961, CACM.

[29]  Gérard Boudol,et al.  Some Chemical Abstract Machines , 1993, REX School/Symposium.

[30]  Davide Sangiorgi,et al.  The Name Discipline of Uniform Receptiveness , 1999, Theor. Comput. Sci..

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

[32]  Jerzy Tiuryn,et al.  Discrimination by parallel observers , 1997, Proceedings of Twelfth Annual IEEE Symposium on Logic in Computer Science.

[33]  Gérard Boudol.  Towards a Lambda-Calculus for Concurrent and Communicating Systems , 1989, TAPSOFT, Vol.1.

[34]  Jan Friso Groote,et al.  Structured Operational Semantics and Bisimulation as a Congruence , 1992, Inf. Comput..

[35]  Alan Jeffrey,et al.  A Chemical Abstract Machine for Graph Reduction , 1993, MFPS.

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

[37]  Davide Sangiorgi,et al.  On Bisimulations for the Asynchronous pi-Calculus , 1996, Theor. Comput. Sci..

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

[39]  Hayo Thielecke,et al.  Categorical Structure of Continuation Passing Style , 1997 .

[40]  John C. Reynolds,et al.  The discoveries of continuations , 1993, LISP Symb. Comput..

[41]  Davide Sangiorgi.  The Lazy Lambda Calculus in a Concurrency Scenario , 1994, Inf. Comput..

[42]  S. Abramsky.  The lazy lambda calculus , 1990 .

[43]  M. Felleisen,et al.  Reasoning about programs in continuation-passing style , 1993 .

[44]  Eugenio Moggi,et al.  Notions of Computation and Monads , 1991, Inf. Comput..

[45]  Carl Hewitt,et al.  Actor induction and meta-evaluation , 1973, POPL.

[46]  Antony J. T. Davie,et al.  p-Calculus Characterizations of some Practical ?-Calculus Reduction Strategies , 1993 .

[47]  Benjamin C. Pierce,et al.  Linearity and the pi-calculus , 1999, TOPL.

[48]  Mitchell Wand,et al.  Essentials of programming languages , 2008 .

[49]  Mark Lillibridge,et al.  Polymorphic type assignment and CPS conversion , 1993, LISP Symb. Comput..

[50]  Robin Milner,et al.  The Problem of "Weak Bisimulation up to" , 1992, CONCUR.

[51]  John C. Mitchell,et al.  Foundations for programming languages , 1996, Foundation of computing series.

[52]  Carl Hewitt,et al.  Viewing Control Structures as Patterns of Passing Messages , 1977, Artif. Intell..

[53]  Bard Bloom.  Can LCF be topped? Flat lattice models of typed lambda calculus , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[54]  David Sands.  From SOS rules to proof principles: an operational metatheory for functional languages , 1997, POPL '97.

[55]  Frits W. Vaandrager,et al.  Turning SOS rules into equations , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

[56]  Olivier Danvy,et al.  Thunks (Continued) , 1992, WSA.

[57]  Naoki Kobayashi.  A partially deadlock-free typed process calculus , 1998, TOPL.

[58]  Davide Sangiorgi,et al.  Expressing mobility in process algebras : first-order and higher-order paradigms , 1993 .

[59]  J. V. Tucker,et al.  Basic Simple Type Theory , 1997 .

[60]  Robin Milner.  Functions as Processes , 1990, ICALP.

[61]  C.-H. Luke Ong,et al.  Full Abstraction in the Lazy Lambda Calculus , 1993, Inf. Comput..

[62]  David N. Turner,et al.  The polymorphic Pi-calculus : theory and implementation , 1996 .

[63]  Gérard Boudol,et al.  Asynchrony and the Pi-calculus , 1992 .

[64]  Robin Milner,et al.  The Polyadic π-Calculus: a Tutorial , 1993 .

[65]  Davide Sangiorgi,et al.  Lazy functions and mobile processes , 2000, Proof, Language, and Interaction.

[66]  C.-H. Luke Ong.  The Lazy Lambda Calculus : an investigation into the foundations of functional programming , 1988 .

[67]  Carl Hewitt,et al.  Laws for Communicating Parallel Processes , 1977, IFIP Congress.

[68]  Robert D. Tennent,et al.  Semantics of programming languages , 1991, Prentice Hall International Series in Computer Science.

[69]  Peter Lee,et al.  Call-by-need and continuation-passing style , 1994, LISP Symb. Comput..

[70]  Michael J. C. Gordon,et al.  The Denotational Description of Programming Languages , 1979, Springer New York.

[71]  A. Church.  The calculi of lambda-conversion , 1941 .

[72]  Andrew D. Gordon.  Bisimilarity as a theory of functional programming , 1995, MFPS.

[73]  Henk Barendregt,et al.  The Lambda Calculus: Its Syntax and Semantics , 1985 .

[74]  John C. Reynolds.  Definitional Interpreters for Higher-Order Programming Languages , 1998, High. Order Symb. Comput..

[75]  Robert Harper,et al.  Typing first-class continuations in ML , 1991, POPL '91.