Back Online

Welcome to Close Encounters of the Logical Kind, version 2.0. This blog, originally hosted on our local wiki at Northeastern University, started life last year as a complement to the ACM SIGACT News Logic Column. Here is what I wrote back then:

This is an informal blog nominally focusing on applications of logic to computer science, although I will naturally focus on my research interests in programming languages, security, and artificial intelligence.

I think it is time to bring it up to the big leagues. So here it is. You can still access the old entries by starting here and working your way backwards. (I am probably not going to bother importing old entries here, especially since I do not know if that is even possible.)

My plan for this 2.0 blog: a weekly post, generally on Friday nights. Talking about the week, and at the very least giving pointers to interesting logic-related papers that have made it across my virtual desk. (Logic here to be taken with a grain of salt, as usual.) A bit like Online Papers in Philosophy, although that’s automated and this is not. So the idea is that even if you do not feel like reading my occasional ramblings, you should get something out of the posts anyways.

My November looks like it will be mainly devoted to getting a few NSF proposals out, so things may be a bit slow as far as posting nontrivial content. The PLDI deadline is also around the corner, and I have a student gearing up to submit some work of ours that I will talk about in due time. So all in all, November does not look as insane as it could be.

This Week’s Online Logic Papers

Local Rely-Guarantee Reasoning, by Xinyu Feng: Rely-Guarantee reasoning is a well-known method for verification of shared-variable concurrent programs. However, it is difficult for users to define rely/guarantee conditions, which specify threads’ behaviors over the whole program state. Recent efforts to combine Separation Logic with Rely-Guarantee reasoning have made it possible to hide thread-local resources, but the shared resources still need to be globally known and specified. This greatly limits the reuse of verified program modules. In this paper, we propose LRG, a new Rely-Guarantee-based logic that brings local reasoning and information hiding to concurrency verification. Our logic, for the first time, supports a frame rule over rely/guarantee conditions so that specifications of program modules only need to talk about the resources used locally, and the certified modules can be reused in different threads without redoing the proof. Moreover, we introduce a new hiding rule to hide the resources shared by a subset of threads from the rest in the system. The support of information hiding not only improves the modularity of Rely-Guarantee reasoning, but also enables the sharing of dynamically allocated resources, which requires adjustment of rely/guarantee conditions.

RCF1: Theories of PR Maps and Partial PR Maps, by Michael Pfender: We give to the categorical theory PR of Primitive Recursion a logically simple, algebraic presentation, via equations between maps, plus one genuine Horner type schema, namely Freyd’s uniqueness of the initialised iterated. Free Variables are introduced – formally – as another names for projections. Predicates \chi: A -> 2 admit interpretation as (formal) Objects {A|\chi} of a surrounding Theory PRA = PR + (abstr) : schema (abstr) formalises this predicate abstraction into additional Objects. Categorical Theory P\hat{R}_A \sqsupset PR_A \sqsupset PR then is the Theory of formally partial PR-maps, having Theory PR_A embedded. This Theory P\hat{R}_A bears the structure of a (still) diagonal monoidal category. It is equivalent to “the” categorical theory of \mu-recursion (and of while loops), viewed as partial PR maps. So the present approach to partial maps sheds new light on Church’s Thesis, “embedded” into a Free-Variables, formally variable-free (categorical) framework.

Three Lectures on Automatic Structures, by Bakhadyr Khoussainov, Mia Minnes: This paper grew out of three tutorial lectures on automatic structures given by the first author at the Logic Colloquium 2007. We discuss variants of automatic structures related to several models of computation: word automata, tree automata, Buchi automata, and Rabin automata. Word automata process finite strings, tree automata process finite labeled trees, Buchi automata process infinite strings, and Rabin automata process infinite binary labeled trees. Automatic structures are mathematical objects which can be represented by (word, tree, Buchi, or Rabin) automata. The study of properties of automatic structures is a relatively new and very active area of research.

Revisiting Coroutines, by Ana Lucia de Moura and Roberto Ierusalimschy: This paper defends the revival of coroutines as a general control abstraction. After proposing a new classification of coroutines, we introduce the concept of full asymmetric coroutines and provide a precise definition for it through an operational semantics. We then demonstrate that full coroutines have an expressive power equivalent to one-shot continuations and oneshot partial continuations. We also show that full asymmetric coroutines and one-shot partial continuations have many similarities, and therefore present comparable benefits. Nevertheless, coroutines are easier implemented and understood, specially in the realm of procedural languages. Finally, we provide a collection of programming examples that illustrate the use of full asymmetric coroutines to support direct and concise implementations of several useful control behaviors, including cooperative multitasking.

Characterising Testing Preorders for Finite Probabilistic Processes, by Yuxin Deng, Matthew Hennessy, Rob van Glabbeek, Carroll Morgan: In 1992 Wang & Larsen extended the may- and must preorders of De Nicola and Hennessy to processes featuring probabilistic as well as nondeterministic choice. They concluded with two problems that have remained open throughout the years, namely to find complete axiomatisations and alternative characterisations for these preorders. This paper solves both problems for finite processes with silent moves. It characterises the may preorder in terms of simulation, and the must preorder in terms of failure simulation. It also gives a characterisation of both preorders using a modal logic. Finally it axiomatises both preorders over a probabilistic version of CSP.

Clone Theory: Its Syntax and Semantics, Applications to Universal Algebra, Lambda Calculus and Algebraic Logic, by Zhaohua Luo: The primary goal of this paper is to present a unified way to transform the syntax of a logic system into certain initial algebraic structure so that it can be studied algebraically. The algebraic structures which one may choose for this purpose are various clones over a full subcategory of a category. We show that the syntax of equational logic, lambda calculus and first order logic can be represented as clones or right algebras of clones over the set of positive integers. The semantics is then represented by structures derived from left algebras of these clones.

On characterising strong bisimilarity in a fragment of CCS with replication, by Daniel Hirschkoff, Damien Pous: We provide a characterisation of strong bisimilarity in a fragment of CCS that contains only prefix, parallel composition, synchronisation and a limited form of replication. The characterisation is not an axiomatisation, but is instead presented as a rewriting system. We discuss how our method allows us to derive a new congruence result in the $\pi$-calculus: congruence holds in the sub-calculus that does not include restriction nor sum, and features a limited form of replication. We have not formalised the latter result in all details.

Structural abstract interpretation, A formal study using Coq, by Yves Bertot: Interpreters are tools to compute approximations for behaviors of a program. These approximations can then be used for optimisation or for error detection. In this paper, we show how to describe an abstract interpreter using the type-theory based theorem prover Coq, using inductive types for syntax and structural recursive programming for the abstract interpreter’s kernel. The abstract interpreter can then be proved correct with respect to a Hoare logic for the programming language.

Deciding Quantifier-Free Presburger Formulas Using Parameterized Solution Bounds, by Sanjit A. Seshia, Randal E. Bryant: Given a formula in quantifier-free Presburger arithmetic, if it has a satisfying solution, there is one whose size, measured in bits, is polynomially bounded in the size of the formula. In this paper, we consider a special class of quantifier-free Presburger formulas in which most linear constraints are difference (separation) constraints, and the non-difference constraints are sparse. This class has been observed to commonly occur in software verification. We derive a new solution bound in terms of parameters characterizing the sparseness of linear constraints and the number of non-difference constraints, in addition to traditional measures of formula size. In particular, we show that the number of bits needed per integer variable is linear in the number of non-difference constraints and logarithmic in the number and size of non-zero coefficients in them, but is otherwise independent of the total number of linear constraints in the formula. The derived bound can be used in a decision procedure based on instantiating integer variables over a finite domain and translating the input quantifier-free Presburger formula to an equi-satisfiable Boolean formula, which is then checked using a Boolean satisfiability solver. In addition to our main theoretical result, we discuss several optimizations for deriving tighter bounds in practice. Empirical evidence indicates that our decision procedure can greatly outperform other decision procedures.

Security Policies as Membranes in Systems for Global Computing, Daniele Gorla, Matthew Hennessy, Vladimiro Sassone: We propose a simple global computing framework, whose main concern is code migration. Systems are structured in sites, and each site is divided into two parts: a computing body, and a membrane, which regulates the interactions between the computing body and the external environment. More precisely, membranes are filters which control access to the associated site, and they also rely on the well-established notion of trust between sites. We develop a basic theory to express and enforce security policies via membranes. Initially, these only control the actions incoming agents intend to perform locally. We then adapt the basic theory to encompass more sophisticated policies, where the number of actions an agent wants to perform, and also their order, are considered.

Notions of Lawvere theory, by Stephen Lack, Jiri Rosicky: Categorical universal algebra can be developed either using Lawvere theories (single-sorted finite product theories) or using monads, and the category of Lawvere theories is equivalent to the category of finitary monads on Set. We show how this equivalence, and the basic results of universal algebra, can be generalized in three ways: replacing Set by another category, working in an enriched setting, and by working with another class of limits than finite products. An important special case involves working with sifted-colimit-preserving monads rather than filtered-colimit-preserving ones.