On Verifying Causal Consistency

Causal consistency is one of the most adopted consistency criteria for distributed implementations of data structures. It ensures that operations are executed at all sites according to their causal precedence. We address the issue of verifying automatically whether the executions of an implementation of a data structure are causally consistent. We consider two problems: (1) checking whether one single execution is causally consistent, which is relevant for developing testing and bug finding algorithms, and (2) verifying whether all the executions of an implementation are causally consistent. We show that the first problem is NP-complete. This holds even for the read-write memory abstraction, which is a building block of many modern distributed systems. Indeed, such systems often store data in key-value stores, which are instances of the read-write memory abstraction. Moreover, we prove that, surprisingly, the second problem is undecidable, and again this holds even for the read-write memory abstraction. However, we show that for the read-write memory abstraction, these negative results can be circumvented if the implementations are data independent, i.e., their behaviors do not depend on the data values that are written or read at each moment, which is a realistic assumption.Comment: extended version of POPL 201

Tools for Verifying Classical and Quantum Superintegrability

Recently many new classes of integrable systems in n dimensions occurring in classical and quantum mechanics have been shown to admit a functionally independent set of 2n-1 symmetries polynomial in the canonical momenta, so that they are in fact superintegrable. These newly discovered systems are all separable in some coordinate system and, typically, they depend on one or more parameters in such a way that the system is superintegrable exactly when some of the parameters are rational numbers. Most of the constructions to date are for n=2 but cases where n>2 are multiplying rapidly. In this article we organize a large class of such systems, many new, and emphasize the underlying mechanisms which enable this phenomena to occur and to prove superintegrability. In addition to proofs of classical superintegrability we show that the 2D caged anisotropic oscillator and a Stackel transformed version on the 2-sheet hyperboloid are quantum superintegrable for all rational relative frequencies, and that a deformed 2D Kepler-Coulomb system is quantum superintegrable for all rational values of a parameter k in the potential

Concurrent Data Structures Linked in Time

Arguments about correctness of a concurrent data structure are typically carried out by using the notion of linearizability and specifying the linearization points of the data structure's procedures. Such arguments are often cumbersome as the linearization points' position in time can be dynamic (depend on the interference, run-time values and events from the past, or even future), non-local (appear in procedures other than the one considered), and whose position in the execution trace may only be determined after the considered procedure has already terminated. In this paper we propose a new method, based on a separation-style logic, for reasoning about concurrent objects with such linearization points. We embrace the dynamic nature of linearization points, and encode it as part of the data structure's auxiliary state, so that it can be dynamically modified in place by auxiliary code, as needed when some appropriate run-time event occurs. We name the idea linking-in-time, because it reduces temporal reasoning to spatial reasoning. For example, modifying a temporal position of a linearization point can be modeled similarly to a pointer update in separation logic. Furthermore, the auxiliary state provides a convenient way to concisely express the properties essential for reasoning about clients of such concurrent objects. We illustrate the method by verifying (mechanically in Coq) an intricate optimal snapshot algorithm due to Jayanti, as well as some clients