Nested Hoare triples and frame rules for higher-order store

Authors:
Jan Schwinghammer;Lars Birkedal;Bernhard Reus;Hongseok Yang
Affiliations:
Saarland University, Saarbrücken;IT University of Copenhagen;University of Sussex, Brighton;Queen Mary, University of London
Venue:
CSL'09/EACSL'09 Proceedings of the 23rd CSL international conference and 18th EACSL Annual conference on Computer science logic
Year:
2009

Citing 7
Cited 19

Separation Logic: A Logic for Shared Mutable Data Structures

LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
An Observationally Complete Program Logic for Imperative Higher-Order Frame Rules

LICS '05 Proceedings of the 20th Annual IEEE Symposium on Logic in Computer Science
Domain-theoretic Foundations of Functional Programming

Domain-theoretic Foundations of Functional Programming
Separation logic, abstraction and inheritance

Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Hiding Local State in Direct Style: A Higher-Order Anti-Frame Rule

LICS '08 Proceedings of the 2008 23rd Annual IEEE Symposium on Logic in Computer Science
Ynot: dependent types for imperative programs

Proceedings of the 13th ACM SIGPLAN international conference on Functional programming
Separation logic for higher-order store

CSL'06 Proceedings of the 20th international conference on Computer Science Logic

Realisability semantics of parametric polymorphism, general references and recursive types

Mathematical Structures in Computer Science
The category-theoretic solution of recursive metric-space equations

Theoretical Computer Science
Verifying generics and delegates

ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
The next 700 separation logics

VSTTE'10 Proceedings of the Third international conference on Verified software: theories, tools, experiments
Step-indexed kripke models over recursive worlds

Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A typed store-passing translation for general references

Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A step-indexed Kripke model of hidden state via recursive properties on recursively defined metric spaces

FOSSACS'11/ETAPS'11 Proceedings of the 14th international conference on Foundations of software science and computational structures: part of the joint European conferences on theory and practice of software
Hoare logic for higher order store using simple semantics

WoLLIC'11 Proceedings of the 18th international conference on Logic, language, information and computation
Verification of unloadable modules

FM'11 Proceedings of the 17th international conference on Formal methods
Verifying object-oriented programs with higher-order separation logic in Coq

ITP'11 Proceedings of the Second international conference on Interactive theorem proving
Specification patterns and proofs for recursion through the store

FCT'11 Proceedings of the 18th international conference on Fundamentals of computation theory
Towards a program logic for JavaScript

POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A semantic foundation for hidden state

FOSSACS'10 Proceedings of the 13th international conference on Foundations of Software Science and Computational Structures
Crowfoot: a verifier for higher-order store programs

VMCAI'12 Proceedings of the 13th international conference on Verification, Model Checking, and Abstract Interpretation
Fictional separation logic

ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Verifying the reflective visitor pattern

Proceedings of the 14th Workshop on Formal Techniques for Java-like Programs
Capsules and Separation

LICS '12 Proceedings of the 2012 27th Annual IEEE/ACM Symposium on Logic in Computer Science
Time Bounds for General Function Pointers

Electronic Notes in Theoretical Computer Science (ENTCS)
Specification patterns for reasoning about recursion through the store

Information and Computation

Quantified Score

Hi-index	0.00

Visualization

Abstract

Separation logic is a Hoare-style logic for reasoning about programs with heap-allocated mutable data structures. As a step toward extending separation logic to high-level languages with ML-style general (higher-order) storage, we investigate the compatibility of nested Hoare triples with several variations of higher-order frame rules. The interaction of nested triples and frame rules can be subtle, and the inclusion of certain frame rules is in fact unsound. A particular combination of rules can be shown consistent by means of a Kripke model where worlds live in a recursively defined ultrametric space. The resulting logic allows us to elegantly prove programs involving stored code. In particular, it leads to natural specifications and proofs of invariants required for dealing with recursion through the store.