Small bisimulations for reasoning about higher-order imperative programs

We introduce a new notion of bisimulation for showing contextual equivalence of expressions in an untyped lambda-calculus with an explicit store, and in which all expressed values, including higher-order values, are storable. Our notion of bisimulation leads to smaller and more tractable relations than does the method of Sumii and Pierce [31]. In particular, our method allows one to write down a bisimulation relation directly in cases where [31] requires an inductive specification, and where the principle of local invariants [22] is inapplicable. Our method can also express examples with higher-order functions, in contrast with the most widely known previous methods [4, 22, 32] which are limited in their ability to deal with such examples. The bisimulation conditions are derived by manually extracting proof obligations from a hypothetical direct proof of contextual equivalence.

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

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

[3]  Mitchell Wand,et al.  Constraint systems for useless variable elimination , 1999, POPL '99.

[4]  Nick Benton,et al.  Relational Reasoning in a Nominal Semantics for Storage , 2005, TLCA.

[5]  Matthias Felleisen,et al.  The calculi of lambda-nu-cs conversion: a syntactic theory of control and state in imperative higher-order programming languages , 1987 .

[6]  Nobuko Yoshida,et al.  A logical analysis of aliasing in imperative higher-order functions , 2007, J. Funct. Program..

[7]  H. Swinnerton-Dyer Publications of the Newton Institute , 1993 .

[8]  Radha Jagadeesan,et al.  Full Abstraction for PCF , 1994, Inf. Comput..

[9]  Andrew M. Pitts,et al.  A Fully Abstract Translation between a Lambda-Calculus with Reference Types and Standard ML , 1995, TLCA.

[10]  Robin Milner,et al.  On Observing Nondeterminism and Concurrency , 1980, ICALP.

[11]  Christopher Strachey,et al.  A theory of programming language semantics , 1976 .

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

[13]  Carolyn L. Talcott,et al.  1 Equivalence in Functional Languages with E ectsIan , 2007 .

[14]  Richard S. Varga,et al.  Proof of Theorem 5 , 1983 .

[15]  Albert R. Meyer,et al.  Towards fully abstract semantics for local variables , 1988, POPL '88.

[16]  Radha Jagadeesan,et al.  A Calculus of Untyped Aspect-Oriented Programs , 2003, ECOOP.

[17]  Davide Sangiorgi,et al.  On the Proof Method for Bisimulation (Extended Abstract) , 1995, MFCS.

[18]  Jerzy Tiuryn,et al.  Untyped Lambda-Calculus with Input-Output , 1996, CAAP.

[19]  Mitchell Wand,et al.  Lightweight closure conversion , 1997, TOPL.

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

[21]  Mitchell Wand,et al.  Denotational semantics using an operationally-based term model , 1997, POPL '97.

[22]  Robin Milner,et al.  Fully Abstract Models of Typed lambda-Calculi , 1977, Theor. Comput. Sci..

[23]  Robin Milner,et al.  Algebraic laws for nondeterminism and concurrency , 1985, JACM.

[24]  Matthias Felleisen,et al.  The semantics of future and its use in program optimization , 1995, POPL '95.

[25]  Albert R. Meyer,et al.  Towards a fully abstract semantics for local variables: Preliminary report , 1988 .

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

[27]  Davide Sangiorgi,et al.  On the bisimulation proof method , 1998, Mathematical Structures in Computer Science.

[28]  Nobuko Yoshida,et al.  An observationally complete program logic for imperative higher-order functions , 2005, 20th Annual IEEE Symposium on Logic in Computer Science (LICS' 05).

[29]  Davide Sangiorgi,et al.  Locality and Interleaving Semantics in Calculi for Mobile Processes , 1996, Theor. Comput. Sci..

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

[31]  Robin Milner,et al.  Operational and Algebraic Semantics of Concurrent Processes , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[32]  I. Stark,et al.  Operational reasoning for functions with local state , 1999 .

[33]  Mitchell Wand,et al.  Macro-by-example: Deriving syntactic transformations from their specifications , 1987, POPL '87.

[34]  Mitchell Wand,et al.  Set constraints for destructive array update optimization , 1998, Proceedings of the 1998 International Conference on Computer Languages (Cat. No.98CB36225).

[35]  Davide Sangiorgi,et al.  Towards an algebraic theory of typed mobile processes , 2006, Theor. Comput. Sci..

[36]  Kurt Sieber Full Abstraction for the Second Order Subset of an Algol-Like Language , 1996, Theor. Comput. Sci..

[37]  Douglas J. Howe Equality in lazy computation systems , 1989, [1989] Proceedings. Fourth Annual Symposium on Logic in Computer Science.

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

[39]  Davide Sangiorgi,et al.  Locality and True-concurrency in Calculi for Mobile Processes , 1994, TACS.