Environmental Bisimulations for Higher-Order Languages

Developing a theory of bisimulation in higher-order languages can be hard. Particularly challenging can be: (1) the proof of congruence, as well as enhancements of the bisimulation proof method with "up-to context" techniques, and (2) obtaining definitions and results that scale to languages with different features. To meet these challenges, we present environmental bisimulations, a form of bisimulation for higher-order languages, and its basic theory. We consider four representative calculi: pure lambda-calculi (call-by-name and call-by-value), call-by-value lambda-calculus with higher-order store, and then higher-order pi-calculus. In each case: we present the basic properties of environmental bisimilarity, including congruence; we show that it coincides with contextual equivalence; we develop some up-to techniques, including up-to context, as examples of possible enhancements of the associated bisimulation method. Unlike previous approaches (such as applicative bisimulations, logical relations, Sumii-Pierce-Koutavas-Wand), our method does not require induction/indices on evaluation derivation/steps (which may complicate the proofs of congruence, transitivity, and the combination with up-to techniques), or sophisticated methods such as Howe's for proving congruence. It also scales from the pure lambda-calculi to the richer calculi with simple congruence proofs.

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

[2]  Amal Ahmed,et al.  Step-Indexed Syntactic Logical Relations for Recursive and Quantified Types , 2006, ESOP.

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

[4]  Glynn Winskel,et al.  Relational Reasoning about Functions and Nondeterminism , 1999 .

[5]  Bent Thomsen,et al.  Plain CHOCS A second generation calculus for higher order processes , 2005, Acta Informatica.

[6]  Davide Sangiorgi,et al.  Bisimulation in name-passing calculi without matching , 1998, Proceedings. Thirteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.98CB36226).

[7]  John C. Reynolds,et al.  Types, Abstraction and Parametric Polymorphism , 1983, IFIP Congress.

[8]  Julian Rathke,et al.  Towards a theory of bisimulation for local names , 1999, Proceedings. 14th Symposium on Logic in Computer Science (Cat. No. PR00158).

[9]  Mitchell Wand,et al.  Bisimulations for Untyped Imperative Objects , 2006, ESOP.

[10]  Davide Sangiorgi,et al.  The Pi-Calculus - a theory of mobile processes , 2001 .

[11]  Alan Schmitt,et al.  The Kell Calculus: A Family of Higher-Order Distributed Process Calculi , 2004, Global Computing.

[12]  Robin Milner,et al.  Pure bigraphs: Structure and dynamics , 2006, Inf. Comput..

[13]  Matthew Hennessy,et al.  A theory of weak bisimulation for Core CML , 1998 .

[14]  Martín Abadi,et al.  A Bisimulation Method for Cryptographic Protocols , 1998, Nord. J. Comput..

[15]  Julian Rathke,et al.  A theory of bisimulation for a fragment of concurrent ML with local names , 2004, Theor. Comput. Sci..

[16]  Erik Palmgren,et al.  Internalising modified realisability in constructive , 2005 .

[17]  Andrew Donald Gordon,et al.  Functional programming and input/output , 1995 .

[18]  Andrew Pitts,et al.  Semantics and Logics of Computation: Operationally-Based Theories of Program Equivalence , 1997 .

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

[20]  David Sands,et al.  Improvement theory and its applications , 1999 .

[21]  Søren B. Lassen,et al.  A complete, co-inductive syntactic theory of sequential control and state , 2007, POPL '07.

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

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

[24]  Davide Sangiorgi,et al.  Bisimulation for Higher-Order Process Calculi , 1994, Inf. Comput..

[25]  Andrew W. Appel,et al.  An indexed model of recursive types for foundational proof-carrying code , 2001, TOPL.

[26]  Mitchell Wand,et al.  Small bisimulations for reasoning about higher-order imperative programs , 2006, POPL '06.

[27]  James H. Morris,et al.  Lambda-calculus models of programming languages. , 1969 .

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

[29]  Matthew Hennessy,et al.  Bisimulation congruences in safe ambients , 2002, POPL '02.

[30]  Soren Lassen.  Relational reasoning about contexts , 1997 .

[31]  Benjamin C. Pierce,et al.  Logical relations for encryption , 2001, Proceedings. 14th IEEE Computer Security Foundations Workshop, 2001..

[32]  Lars Birkedal,et al.  Relational Interpretations of Recursive Types in an Operational Setting , 1999, Inf. Comput..

[33]  Thomas T. Hildebrandt,et al.  Extending Howe's Method to Early Bisimulations for Typed Mobile Embedded Resources with Local Names , 2005, FSTTCS.

[34]  Francesco Zappa Nardelli,et al.  Behavioural Theory for Mobile Ambients , 2004, IFIP TCS.

[35]  Benjamin C. Pierce,et al.  Logical relation for encryption , 2003 .

[36]  Julian Rathke,et al.  Contextual equivalence for higher-order pi-calculus revisited , 2005, Log. Methods Comput. Sci..

[37]  Davide Sangiorgi,et al.  Behavioral equivalence in the polymorphic pi-calculus , 2000, JACM.

[38]  Benjamin C. Pierce,et al.  A bisimulation for dynamic sealing , 2007, Theor. Comput. Sci..

[39]  Nobuko Yoshida,et al.  On Reduction-Based Process Semantics , 1995, Theor. Comput. Sci..

[40]  Benjamin C. Pierce,et al.  A bisimulation for type abstraction and recursion , 2005, POPL '05.

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