Reverse Bisimulations on Stable Configuration Structures

The relationships between various equivalences on configuration structures, including interleaving bisimulation (IB), step bisimulation (SB) and hereditary history-preserving (HH) bisimulation, have been investigated by van Glabbeek and Goltz (and later Fecher). Since HH bisimulation may be characterised by the use of reverse as well as forward transitions, it is of interest to investigate forms of IB and SB where both forward and reverse transitions are allowed. We give various characterisations of reverse SB, showing that forward steps do not add extra power. We strengthen Bednarczyk’s result that, in the absence of auto-concurrency, reverse IB is as strong as HH bisimulation, by showing that we need only exclude auto-concurrent events at the same depth in the configuration.

💡 Research Summary

The paper investigates the expressive power of bisimulation equivalences on stable configuration structures when both forward and reverse transitions are permitted. Traditional equivalences—interleaving bisimulation (IB) and step bisimulation (SB)—consider only forward moves, while hereditary history‑preserving bisimulation (HH) incorporates reverse steps as well, giving it a finer discriminating ability. The authors introduce two reverse‑oriented equivalences: reverse interleaving bisimulation (RIB) and reverse step bisimulation (RSB).

First, the authors formalise stable configuration structures as labelled transition systems equipped with a partial order (causality) and a conflict relation, ensuring each configuration is finite and closed under down‑closure. They then define reverse transitions as operations that remove a maximal event from a configuration, preserving causality and conflict constraints. RIB requires a relation between configurations that matches forward and reverse single‑event steps with identical labels, while RSB extends this to forward steps that may contain multiple concurrent events.

The central technical contributions are two theorems. Theorem 1 shows that forward steps add no extra distinguishing power to RSB: any RSB relation can be simulated using only reverse steps, because forward multi‑event steps can be decomposed into a sequence of reverse steps followed by appropriate forward single‑event steps, preserving the bisimulation conditions. Consequently, RSB collapses to a purely reverse‑step based equivalence.

Theorem 2 strengthens a prior result by Bednarczyk concerning RIB. It proves that if a configuration structure contains no auto‑concurrent events at the same depth (i.e., two distinct events with the same label that are concurrent and appear at the same level of the causality hierarchy), then RIB coincides with HH bisimulation. The proof constructs a history‑preserving mapping from the reverse‑step correspondence, showing that the reverse relation already guarantees the preservation of causal histories when the depth‑restricted auto‑concurrency condition holds. This relaxes the earlier requirement of globally forbidding auto‑concurrency, making the result applicable to a broader class of systems where concurrent identical actions may appear at different depths (e.g., nested transactions).

Methodologically, the authors employ structural induction on configurations, careful case analysis of forward versus reverse moves, and a mapping technique that translates reverse bisimulation relations into history‑preserving isomorphisms. They also discuss how the depth notion can be computed efficiently from the partial order, enabling practical checks for the required restriction.

The paper’s significance lies in demonstrating that reverse transitions alone suffice to capture the full discriminating power of HH under mild syntactic constraints, and that forward step transitions do not increase the expressive strength of reverse step bisimulation. This insight simplifies the design of verification tools: instead of implementing the full HH machinery (which requires tracking entire causal histories), one can implement a reverse‑only bisimulation checker, gaining comparable precision with lower computational overhead.

Finally, the authors outline future work, suggesting extensions to non‑stable configuration structures, integration with event‑structure models, and the development of automated tools that exploit the depth‑restricted auto‑concurrency condition to optimise equivalence checking in real‑world concurrent systems.