# Separation logic: a logic for shared mutable data structures

@article{Reynolds2002SeparationLA, title={Separation logic: a logic for shared mutable data structures}, author={John C. Reynolds}, journal={Proceedings 17th Annual IEEE Symposium on Logic in Computer Science}, year={2002}, pages={55-74} }

In joint work with Peter O'Hearn and others, based on early ideas of Burstall, we have developed an extension of Hoare logic that permits reasoning about low-level imperative programs that use shared mutable data structure. The simple imperative programming language is extended with commands (not expressions) for accessing and modifying shared structures, and for explicit allocation and deallocation of storage. Assertions are extended by introducing a "separating conjunction" that asserts that… Expand

#### Supplemental Presentations

#### Topics from this paper

#### 2,407 Citations

Variables as Resource for Shared-Memory Programs: Semantics and Soundness

- Computer Science
- MFPS
- 2006

This work provides a denotational semantics and a soundness proof for the concurrent fragment of their logic, extending earlier work on concurrent separation logic to incorporate permissions in a natural manner. Expand

Separation Logic for Higher-Order Store

- Computer Science
- CSL
- 2006

This paper introduces an extension of the logic and proves it sound, including the Frame Rule that enables specifications of code to be extended by invariants on parts of the heap that are not accessed, and introduces the benefits of local reasoning available to languages with higher-order store. Expand

Tutorial on Separation Logic (Invited Tutorial)

- Computer Science
- CAV
- 2008

This tutorial covers the basics of separating conjunction logic, and describes how that is, and where rough edges lie (programs whose proofs are still more complex than the authors would like). Expand

An Outline of Separation Logic

- Computer Science, Mathematics
- ArXiv
- 2017

This paper introduces Separation Logic as an extension of the standard Hoare Logic with the help of a programming language that has four pointer manipulating commands. Expand

Recursive Data Structures in SPARK

- Computer Science
- CAV
- 2020

This paper presents a recent extension of the SPARK language and toolset to support pointers, based on an ownership policy inspired by Rust to enforce non-aliasing through a move semantics of assignment. Expand

Amortised Resource Analysis with Separation Logic

- Computer Science
- ESOP
- 2010

This work translates the idea of amortised resource analysis to imperative languages by embedding a logic of resources, based on Bunched Implications, within Separation Logic within Coq proof assistant. Expand

Structured Types and Separation Logic

- Computer Science
- Electron. Notes Theor. Comput. Sci.
- 2008

A generalisation of an earlier formal memory model that captured the low-level features of C's pointers and memory and formed the basis for an expressive implementation of separation logic, with new features providing explicit support for C's structured types is presented. Expand

Recursive Assertions for Data Structures

- Mathematics
- 2007

We present an assertion language for expressing properties of data structures. Its key features are constraints over arrays, multisets and integers which allow the specification of basic assertio ns,… Expand

Separation Logic in the Presence of Garbage Collection

- Computer Science
- 2011 IEEE 26th Annual Symposium on Logic in Computer Science
- 2011

GCSL permits reasoning about programs that use internal pointers and address arithmetic, supports logical variables that range over pointers, and validates the "frame" rule, as well as a standard interpretation of separation-logic assertions, without requiring any restrictions on existentially-quantified formulae. Expand

L3: A Linear Language with Locations

- Mathematics, Computer Science
- Fundam. Informaticae
- 2005

We present a simple, but expressive type system that supports strong updates - updating a memory cell to hold values of unrelated types at different points in time. Our formulation is based upon a… Expand

#### References

SHOWING 1-10 OF 45 REFERENCES

Local Reasoning about Programs that Alter Data Structures

- Computer Science
- CSL
- 2001

An extension of Hoare's logic for reasoning about programs that alter data structures is described, based on a possible worlds model of the logic of bunched implications, and includes spatial conjunction and implication connectives alongside those of classical logic. Expand

Intuitionistic reasoning about shared mutable data structure

- Computer Science
- 1999

This work extends Hoare's approach to proving the correctness of imperative programs, to deal with programs that perform destructive updates to data structures containing more than one pointer to the same location. Expand

BI as an assertion language for mutable data structures

- Computer Science
- POPL '01
- 2001

A model in which the law of the excluded middleholds is given is given, thus showing that the approach is compatible with classical logic, and a local character enjoyed by specifications in the logic is described, which enables a class of frame axioms, which say what parts of the heap don't change, to be inferred automatically. Expand

On Garbage and Program Logic

- Computer Science
- FoSSaCS
- 2001

This work presents a semantics of program logic assertions based on a view of the heap as finite, but extensible; this is for a logical language with primitives for dereferencing pointer expressions, and uses the assertion language to formulate notions of partial and total correctness for a small programming language. Expand

Semantic and Logical Properties of Stateful Programming

- Computer Science
- 2002

This thesis presents and studies a number of problems that arise when reasoning about imperative languages with pointers, with special emphasis on program logic in the style of Hoare, and proposes two approaches, simpler than previous ones, for proving type safety. Expand

An Example of Local Reasoning in BI Pointer Logic: the Schorr−Waite Graph Marking Algorithm

- Computer Science
- 2001

The promise of local reasoning in BI pointer logic is shown by an example: the Schorr-Waite graph marking algorithm, giving an evidence that even in a program with no clear separations of data structures, the locality of memory access can still be exploited in a formal proof with Frame Introduction and BI multiplicative connectives and that the resulting veriication becomes signiicantly simpler. Expand

Computability and Complexity Results for a Spatial Assertion Language for Data Structures

- Computer Science
- APLAS
- 2001

It is shown that validity, even for this restricted language, is not r.e., but that the quantifier-free sublanguage is decidable, and the complexity of model checking and validity for several fragments is considered. Expand

Program logic and equivalence in the presence of garbage collection

- Computer Science
- Theor. Comput. Sci.
- 2003

A study of a small language whose operational semantics includes a rule for reclaiming garbage and results include an analysis of propositions that are garbage insensitive, and full abstraction results connecting partial and total correctness to two natural notions of observational equivalence between programs. Expand

Alias Types for Recursive Data Structures

- Computer Science
- Types in Compilation
- 2000

This paper describes a pseudo-linear type system that allows a degree of aliasing and memory reuse as well as the ability to define complex recursive data structures and demonstrates the flexibility of the type system by encoding two common space-conscious algorithms: destination-passing style and Deutsch-Schorr-Waite or "link-reversal" traversal algoithms. Expand

Stack-based typed assembly language

- Computer Science
- Journal of Functional Programming
- 2002

STAL is a variant of Typed Assembly Language with constructs and types to support a limited form of stack allocation and the type system of STAL ensures that a wide class of errors cannot occur at run time, and therefore the language can be adapted for use in certifying compilers where security is a concern. Expand