Reasoning about imperative and higher-order programs

Contextual equivalence, namely the property that two expressions are indistinguishable inside any program context, is a fundamental property of program expressions. Discovering methods that enable formal reasoning about contextual equivalence is hard and highly dependent on the features of the programming language. In this dissertation we present a technique for systematically deriving reasoning methods for contextual equivalence, which are sound and complete in a variety of languages, but also useful for proving many equivalences. The advantages of the derived reasoning methods are that they successfully deal with imperative as well as higher-order features. We demonstrate our technique by deriving sound and complete methods for proving contextual equivalence in the call-by-value lambda calculus, a lambda calculus with higher-order store, the nu-calculus, an imperative object calculus, and an imperative core of Java.

[1]  Samson Abramsky,et al.  Linearity, Sharing and State: a fully abstract game semantics for Idealized Algol with active expressions , 1996, Electron. Notes Theor. Comput. Sci..

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

[3]  Julian Rathke,et al.  Java Jr: Fully Abstract Trace Semantics for a Core Java Language , 2005, ESOP.

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

[5]  Ian David Bede Stark,et al.  Names and higher-order functions , 1994 .

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

[7]  Lars Birkedal,et al.  Relational Reasoning for Recursive Types and References , 2006, APLAS.

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

[9]  Lars Birkedal,et al.  Polymorphism and separation in hoare type theory , 2006, ICFP '06.

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

[11]  Andrew M. Pitts,et al.  Observable Properties of Higher Order Functions that Dynamically Create Local Names, or What's new? , 1993, MFCS.

[12]  John C. Reynolds,et al.  Separation logic: a logic for shared mutable data structures , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[13]  Andrew M. Pitts,et al.  MJ: An imperative core calculus for Java and Java with effects , 2003 .

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

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

[16]  Dan R. Ghica,et al.  Abstract Models of Storage , 2000, High. Order Symb. Comput..

[17]  Andrew D. Gordon,et al.  Bisimilarity for a first-order calculus of objects with subtyping , 1996, POPL '96.

[18]  Davide Sangiorgi,et al.  Environmental Bisimulations for Higher-Order Languages , 2007, 22nd Annual IEEE Symposium on Logic in Computer Science (LICS 2007).

[19]  Matthias Felleisen,et al.  A Programmer's Reduction Semantics for Classes and Mixins , 1999, Formal Syntax and Semantics of Java.

[20]  Andrzej S. Murawski,et al.  Nominal games and full abstraction for the nu-calculus , 2004, LICS 2004.

[21]  Søren B. Lassen,et al.  Eager normal form bisimulation , 2005, 20th Annual IEEE Symposium on Logic in Computer Science (LICS' 05).

[22]  I. Stark,et al.  On the Observable Properties of Higher Order Functions that Dynamically Create Local Names (Preliminary Report) , 1993 .

[23]  Davide Sangiorgi,et al.  Logical bisimulations and functional languages , 2007, FSEN'07.

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

[25]  M. Wand,et al.  Reasoning About Class Behavior , 2006 .

[26]  Andrew D. Gordon,et al.  Compilation and Equivalence of Imperative Objects , 1997 .

[27]  Samson Abramsky,et al.  A fully abstract game semantics for general references , 1998, Proceedings. Thirteenth Annual IEEE Symposium on Logic in Computer Science (Cat. No.98CB36226).

[28]  Radha Jagadeesan,et al.  Open bisimulation for aspects , 2007, LNCS Trans. Aspect Oriented Softw. Dev..

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

[30]  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).

[31]  James Laird.  A Fully Abstract Trace Semantics for General References , 2007, ICALP.

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

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

[34]  Julian Rathke,et al.  A fully abstract may testing semantics for concurrent objects , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

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

[36]  Davide Sangiorgi.  The Bisimulation Proof Method: Enhancements and Open Problems , 2006, FMOODS.

[37]  Umut A. Acar,et al.  Imperative self-adjusting computation , 2008, POPL '08.

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

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

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

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

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

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

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

[45]  Anindya Banerjee,et al.  Ownership confinement ensures representation independence for object-oriented programs , 2002, JACM.

[46]  Nick Benton,et al.  A Mechanized Bisimulation for the Nu-Calculus , 2008 .

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

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

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

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

[51]  C. A. R. HOARE,et al.  An axiomatic basis for computer programming , 1969, CACM.

[52]  Samson Abramsky,et al.  Full Abstraction for Idealized Algol with Passive Expressions , 1999, Theor. Comput. Sci..

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

[54]  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 .

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

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

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

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