Symmetric and Asymmetric Asynchronous Interaction

We investigate classes of systems based on different interaction patterns with the aim of achieving distributability. As our system model we use Petri nets. In Petri nets, an inherent concept of simultaneity is built in, since when a transition has more than one preplace, it can be crucial that tokens are removed instantaneously. When modelling a system which is intended to be implemented in a distributed way by a Petri net, this built-in concept of synchronous interaction may be problematic. To investigate this we consider asynchronous implementations of nets, in which removing tokens from places can no longer be considered as instantaneous. We model this by inserting silent (unobservable) transitions between transitions and some of their preplaces. We investigate three such implementations, differing in the selection of preplaces of a transition from which the removal of a token is considered time consuming, and the possibility of collecting the tokens in a given order. We investigate the effect of these different transformations of instantaneous interaction into asynchronous interaction patterns by comparing the behaviours of nets before and after insertion of the silent transitions. We exhibit for which classes of Petri nets we obtain equivalent behaviour with respect to failures equivalence. It turns out that the resulting hierarchy of Petri net classes can be described by semi-structural properties. For two of the classes we obtain precise characterisations; for the remaining class we obtain lower and upper bounds. We briefly comment on possible applications of our results to Message Sequence Charts.

💡 Research Summary

The paper addresses a fundamental mismatch between the intrinsic synchrony of classic Petri nets and the realities of distributed implementation. In a standard Petri net, a transition that has multiple input places removes tokens from all those places instantaneously. This built‑in simultaneity is often unrealistic when the net is intended to be executed on physically separate components. To study the impact of replacing this synchronous token consumption with an asynchronous one, the authors introduce three systematic transformations that insert silent (τ) transitions between a transition and selected input places.

The first transformation, called symmetric asynchronous, inserts a τ‑transition for every input place, thereby forcing each token to be fetched one after another. The second, asymmetric asynchronous, selects a subset of input places for which τ‑transitions are added, leaving the remaining inputs to be consumed synchronously. The third transformation adds the possibility of ordering constraints on the token collection: either a strict order must be respected or the order is left unrestricted.

To compare the behaviour of the original net with its transformed counterpart, the authors employ failures equivalence, a semantic relation that records both the set of observable actions a system can perform and the sets of actions it can refuse after a given trace. This equivalence is sensitive enough to capture subtle differences introduced by the asynchronous insertions while still being tractable for structural analysis.

The main technical contribution is a hierarchy of Petri‑net classes defined by semi‑structural properties that guarantee preservation of failures equivalence under each transformation. For the symmetric asynchronous case, the authors identify the class of “pre‑post‑free” nets: nets in which no transition simultaneously requires tokens from more than one place that are themselves involved in conflicts. Such nets are conflict‑free and have a tree‑like causal structure, ensuring that the order of token removal does not affect observable behaviour.

In the asymmetric case, the preservation condition becomes more intricate. The authors define “pre‑post isolation”: the set of input places that are made asynchronous must be structurally separated from the synchronous ones, i.e., there must be no reachable marking where a token from an asynchronous input can enable a transition that also needs a token from a synchronous input. Nets satisfying this isolation property retain failures equivalence after the selective insertion of τ‑transitions.

The third class, which deals with ordered token collection, is only partially characterised. The authors provide lower and upper bounds: at the lower bound, nets that are completely order‑preserving (every transition’s input places can be linearised without creating new conflicts) preserve equivalence; at the upper bound, nets that are completely order‑independent (the order of token arrival never influences enabledness) also preserve equivalence. Between these bounds the situation remains open, and the paper supplies illustrative examples that delineate the gap.

Beyond the theoretical analysis, the paper sketches an application to Message Sequence Charts (MSCs). MSCs describe interactions as sequences of messages exchanged between components, often assuming synchronous send/receive semantics. By mapping MSC fragments onto Petri nets and applying the asynchronous transformations, designers can detect when an MSC specification would lead to hidden synchronisation points in a distributed implementation. The semi‑structural criteria derived in the paper thus become practical guidelines for verifying that an MSC can be realised without introducing unintended blocking behaviour.

In summary, the authors develop a rigorous framework for converting synchronous Petri‑net specifications into asynchronous ones, identify precise structural conditions under which the observable behaviour (as captured by failures equivalence) is preserved, and demonstrate how these results can inform the safe design of distributed systems and their high‑level specifications such as MSCs. The work bridges the gap between formal net theory and practical concerns of distributability, offering both deep theoretical insight and actionable engineering criteria.