Reasoning about Multi-process Systems with the Box Calculus

Abstract

Abstract. The box calculus is a formalism for reasoning about the properties of multi-process systems which enables account to be taken of pragmatic as well as computational concerns. It was developed for the programming language Hume which explicitly distinguishes between coordination, based on concurrent boxes linked by wires, and expressions, based on polymorphic recursive functions. This chapter introduces Hume expressions and surveys classic techniques for reasoning about functional programs. It then explores Hume coordination and the box calculus, and examines how Hume programs may be systematically transformed while maintaining computational and pragmatic correctness. OverviewHaving constructed programs that meet their specifications, we often want to change them to take advantage of changing operating environments. For example, we might want to migrate a program from environments with smaller to larger numbers of processors to improve performance, in particular as the number of cores grows in new generations of the same CPU architecture. In changing programs, we want to ensure not only they still meet their original specifications, but also that their pragmatic (i.e. time, space, sequencing) behaviours change in well understood ways. In particular, in making what appear to be local improvements to a program, for example by introducing parallelism, we want to avoid unexpected global impacts that make overall performance worse, for example as a result of unanticipated additional communication or scheduling costs. Thus, we need some means of reasoning about changes to programs that can account for pragmatic as well as computational program properties.Most software is constructed in imperative programming languages; abstractions from von Neumann architectures 1 based on sequences of state changes mediated by mutable memory. Here, different program components interact by manipulating the same memory areas. Thus, changing the order of component execution often changes the sequence of memory manipulation, changing what the program does. This complicates reasoning about imperative programs because the state change sequencing must be made explicit in the reasoning 1 And also Harvard architectures.

Harnessing parallelism in FPGAs using the hume language

“…Third, by trying to apply the Hume box calculus [7,8,13] to the (semi)-automatic derivation of the relatively low-level formulations of mHume programs from higher levels specifications (as a set of function calls for instance).…”

“…This provides a small set of base transformations for introducing and eliminating boxes and wires, and for moving activities between coordination and computation. From this base set, richer transformations have been elaborated and proved correct, for example to realise function composition as vertical pipeline parallelism [8], and map [8] and fold [13] over lists as divide and conquer parallelism. Thus, an initial pure functional expression of a program may be systematically refined into interconnected boxes for potential parallel realisation.…”

Abstract structure of unitary oracles for quantum algorithms

“…These dagger compact categories are symmetric monoidal categories with additional structure covered Chapter 3. SMC based string diagrammatic theories also appear in interactive theorem proving [51], parallel programming [82], programming language semantics [79], and natural language processing [38]. This final connection is elaborated on and leveraged in Chapter 6.…”

Quantomatic: A Proof Assistant for Diagrammatic Reasoning

“…Recently, there has been much interest in diagrammatic theories in a wide variety of areas such as Petri nets [27], programming language semantics [21], natural language processing [5], systems biology [7], control theory [2,4], program parallelisation [23], and in interactive theorem proving [12]. It has also played a major role in categorical quantum mechanics [1].…”