Specifying and Verifying Concurrent Algorithms with Histories and Subjectivity

TL;DR

This paper introduces a lightweight, history-based specification method for fine-grained concurrent algorithms, enabling formal reasoning about complex behaviors and ownership transfer using a unifying algebraic framework validated in Coq.

Contribution

It presents a novel history-based specification approach that models concurrent changes as partial commutative monoids, unifying resource reasoning and ownership transfer in concurrency.

Findings

Histories form a partial commutative monoid, enabling algebraic reasoning.

The approach unifies histories and heaps under the same assertion logic.

All examples were validated in Coq, demonstrating practical applicability.

Abstract

We present a lightweight approach to Hoare-style specifications for fine-grained concurrency, based on a notion of time-stamped histories that abstractly capture atomic changes in the program state. Our key observation is that histories form a partial commutative monoid, a structure fundamental for representation of concurrent resources. This insight provides us with a unifying mechanism that allows us to treat histories just like heaps in separation logic. For example, both are subject to the same assertion logic and inference rules (e.g., the frame rule). Moreover, the notion of ownership transfer, which usually applies to heaps, has an equivalent in histories. It can be used to formally represent helping---an important design pattern for concurrent algorithms whereby one thread can execute code on behalf of another. Specifications in terms of histories naturally abstract granularity, in the sense that sophisticated fine-grained algorithms can be given the same specifications as their simplified coarse-grained counterparts, making them equally convenient for client-side reasoning. We illustrate our approach on a number of examples and validate all of them in Coq.