Linearity and the pi-calculus

The economy and flexibility of the pi-calculus make it an attractive object of theoretical study and a clean basis for concurrent language design and implementation. However, such generality has a cost: encoding higher-level features like functional computation in pi-calculus throws away potentially useful information. We show how a linear type system can be used to recover important static information about a process's behavior. In particular, we can guarantee that two processes communicating over a linear channel cannot interfere with other communicating processes. After developing standard results such as soundness of typing, we focus on equivalences, adapting the standard notion of barbed bisimulation to the linear setting and showing how reductions on linear channels induce a useful “partial confluence” of process behaviors. For an extended example of the theory, we prove the validity of a tail-call optimization for higher-order functions represented as processes.

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

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

[3]  John H. Reppy,et al.  CML: A higher concurrent language , 1991, PLDI '91.

[4]  Akinori Yonezawa,et al.  Higher-Order Concurrent Linear Logic Programming , 1994, Theory and Practice of Parallel Programming.

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

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

[7]  Davide Sangiorgi Typed pi-calculus at Work: A Correctness Proof of Jones's Parallelisation Transformation on Concurrent Objects , 1999, Theory Pract. Object Syst..

[8]  J. Davenport Editor , 1960 .

[9]  B. Pierce,et al.  Typing and subtyping for mobile processes , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[10]  Rajagopal Nagarajan,et al.  Interaction categories and the foundations of typed concurrent programming , 1996, NATO ASI DPD.

[11]  David Walker,et al.  A Polymorphic Type System for the Polyadic pi-calculus , 1995, CONCUR.

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

[13]  Cédric Fournet,et al.  The reflexive CHAM and the join-calculus , 1996, POPL '96.

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

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

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

[17]  Uwe Nestmann Typing Confluence , 1997 .

[18]  Robin Milner,et al.  Functions as processes , 1990, Mathematical Structures in Computer Science.

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

[20]  Martin Odersky,et al.  Polarized Name Passing , 1995, FSTTCS.

[21]  Benjamin C. Pierce,et al.  Pict: a programming language based on the Pi-Calculus , 2000, Proof, Language, and Interaction.

[22]  Peter W. O'Hearn,et al.  Syntactic Control of Interference Revisited , 1999, Theor. Comput. Sci..

[23]  Kohei Honda,et al.  Types for Dynamic Interaction , 1993 .

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

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

[26]  Davide Sangiorgi,et al.  Typing and subtyping for mobile processes , 1993, [1993] Proceedings Eighth Annual IEEE Symposium on Logic in Computer Science.

[27]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[28]  Kohei Honda,et al.  Types for Dyadic Interaction , 1993, CONCUR.

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

[30]  de Ng Dick Bruijn,et al.  Lambda calculus notation with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem , 1972 .

[31]  Kohei Honda,et al.  An Interaction-based Language and its Typing System , 1994, PARLE.

[32]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

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

[34]  Benjamin C. Pierce,et al.  Concurrent Objects in a Process Calculus , 1994, Theory and Practice of Parallel Programming.

[35]  Rajagopal Nagarajan,et al.  A typed calculus of synchronous processes , 1995, Proceedings of Tenth Annual IEEE Symposium on Logic in Computer Science.

[36]  Atsushi Igarashi,et al.  Type-Based Analysis of Communication for Concurrent Programming Languages , 1997, SAS.

[37]  Kohei Honda,et al.  Composing processes , 1996, POPL '96.

[38]  Flemming Nielson,et al.  Static and Dynamic Processor Allocation for Higher-Order Concurrent Languages , 1995, TAPSOFT.

[39]  Eike Best CONCUR'93 , 1993, Lecture Notes in Computer Science.

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

[41]  Vasco Thudichum Vasconcelos,et al.  Principal Typing Schemes in a Polyadic pi-Calculus , 1993, CONCUR.

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

[43]  Flemming Nielson,et al.  Higher-order concurrent programs with finite communication topology (extended abstract) , 1994, POPL '94.

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

[45]  John H. Reppy,et al.  CML: A Higher-Order Concurrent Language , 1991, PLDI.

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

[47]  Simon J. Gay,et al.  A sort inference algorithm for the polyadic π-calculus , 1993, POPL '93.

[48]  Bernard Robinet,et al.  Combinators and functional programming languages : Thirteenth Spring School of the LITP, Val d'Ajol, France, May 6-10, 1985, proceedings , 1986 .

[49]  David Walker,et al.  Objects in the pi-Calculus , 1992, Inf. Comput..

[50]  Insup Lee,et al.  CONCUR '95: Concurrency Theory , 1995, Lecture Notes in Computer Science.

[51]  Vasco Thudichum Vasconcelos,et al.  Typed Concurrent Objects , 1994, ECOOP.

[52]  Philip Wadler Is there a use for linear logic , 1991 .

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

[54]  Akinori Yonezawa,et al.  Towards Foundations of Concurrent Object-Oriented Programming-Types and Language Design , 1995, Theory Pract. Object Syst..

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

[56]  Peter W. O'Hearn,et al.  Syntactic control of interference revisited , 1995, MFPS.

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

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

[59]  Cliff B. Jones A pi-Calculus Semantics for an Object-Based Design Notation , 1993, CONCUR.

[60]  J. S. Hodas Lolli: An Extension of λProlog with Linear Context Management , 1992 .

[61]  Nobuko Yoshida,et al.  Combinatory representation of mobile processes , 1994, POPL '94.

[62]  David Walker,et al.  Confluence of Processes and Systems of Objects , 1995, TAPSOFT.

[63]  Robin Milner The Polyadic Pi-calculus (Abstract) , 1992, CONCUR.

[64]  Davide Sangiorgi,et al.  An Investigation into Functions as Processes , 1993, MFPS.

[65]  Luca Cardelli. Amber Combinators and Functional Programming Languages , 1985, Lecture Notes in Computer Science.

[66]  Philip Wadler,et al.  Once upon a type , 1995, FPCA '95.

[67]  Jean-Jacques Lévy,et al.  A Calculus of Mobile Agents , 1996, CONCUR.