Bipartite graphs as polynomials and polynomials as bipartite graphs

The aim of this paper is to show that any finite undirected bipartite graph can be considered as a polynomial [Formula: see text], and any directed finite bipartite graph can be considered as a polynomial [Formula: see text], and vise verse. We also show that the multiplication in the semirings [Formula: see text], [Formula: see text] corresponds to an operation of the corresponding graphs. This operation is exactly the product of Petri nets in the sense of Winskel [G. Winskel and M. Nielsen, Models of concurrency, in Handbook of Logic in Computer Science, Vol. 4, eds. Abamsky, Gabbay and Maibaum (Oxford University Press, 1995), pp. 1–148]. As an application, we give an approach to dividing in the semirings [Formula: see text], [Formula: see text], and a criteria for parallalization of Petri nets. Finally, we endow the set of all bipartite graphs with the Zariski topology.

Compositional relaxed concurrency

There is a broad design space for concurrent computer processors: they can be optimized for low power, low latency or high throughput. This freedom to tune each processor design to its niche has led to an increasing diversity of machines, from powerful pocketable devices to those responsible for complex and critical tasks, such as car guidance systems. Given this context, academic concurrency research sounds notes of both caution and optimism. Caution because recent work has uncovered flaws in the way we explain the subtle memory behaviour of concurrent systems: specifications have been shown to be incorrect, leading to bugs throughout the many layers of the system. And optimism because our tools and methods for verifying the correctness of concurrent code—although built above an idealized model of concurrency—are becoming more mature. This paper looks at the way we specify the memory behaviour of concurrent systems and suggests a new direction. Currently, there is a siloed approach, with each processor and programming language specified separately in an incomparable way. But this does not match the structure of our programs, which may use multiple processors and languages together. Instead we propose a compositional approach, where program components carry with them a description of the sort of concurrency they rely on, and there is a mechanism for composing these. This will support not only components written for the multiple varied processors found in a modern system but also those that use idealized models of concurrency, providing a sound footing for mature verification techniques. This article is part of the themed issue ‘Verified trustworthy software systems’.