An expressively complete local past propositional dynamic logic over Mazurkiewicz traces and its applications

We propose a local, past-oriented fragment of propositional dynamic logic to reason about concurrent scenarios modelled as Mazurkiewicz traces, and prove it to be expressively complete with respect to regular trace languages. Because of locality, specifications in this logic are efficiently translated into asynchronous automata, in a way that reflects the structure of formulas. In particular, we obtain a new proof of Zielonka’s fundamental theorem and we prove that any regular trace language can be implemented by a cascade product of localized asynchronous automata, which essentially operate on a single process. These results refine earlier results by Adsul et al. which involved a larger fragment of past propositional dynamic logic and used Mukund and Sohoni’s gossip automaton. Our new results avoid using this automaton, or Zielonka’s timestamping mechanism and, in particular, they show how to implement a gossip automaton as a cascade product.

💡 Research Summary

The paper introduces a novel fragment of propositional dynamic logic (PDL) called Local Past PDL (LP‑PDL), designed specifically for reasoning about concurrent computations modeled as Mazurkiewicz traces. The authors start by recalling the standard trace theory: a trace is a partially ordered word over a distributed alphabet, and regular trace languages are those recognized by asynchronous automata. While previous work (e.g., Adsul et al., 2005) employed a fairly large past‑oriented PDL to capture regular trace languages, the resulting specifications were global in nature and required sophisticated constructions such as Mukund and Sohoni’s gossip automaton or Zielonka’s timestamping mechanism.

LP‑PDL departs from these approaches by imposing locality on every formula. An atomic proposition is attached to a single process, and program constructs (sequential composition, choice, iteration, and a local test operator) are allowed to act only on the alphabet of that process. The past operators are deliberately restricted: “◁a” means that action a occurred immediately before the current event on the same process, and “◁*a” means that a occurred sometime earlier on that process. This limited view of the past is sufficient to express any regular trace language, yet it avoids the combinatorial blow‑up associated with unrestricted past modalities.

The core technical contribution is a two‑directional expressive‑completeness proof. In the forward direction, given any regular trace language L, the authors construct an asynchronous automaton A that recognizes L. The construction follows the classic Zielonka construction but is performed on the level of local components, yielding a family of deterministic local automata whose synchronous product reproduces the global behavior. In the reverse direction, they present an algorithm that translates any LP‑PDL formula φ into an equivalent asynchronous automaton Aφ. The translation proceeds recursively over the syntax tree of φ: atomic propositions become local transitions, program constructs become standard automata operations, and past operators are realized by adding backward‑propagation edges that only involve the relevant process. Crucially, the size of Aφ is linear in the size of φ, and the structure of Aφ mirrors the syntactic structure of φ, which is a marked improvement over previous translations that required exponential blow‑up or auxiliary gossip mechanisms.

Armed with this translation, the authors give a new proof of Zielonka’s theorem. Instead of relying on a global timestamping scheme, they show that the asynchronous automaton obtained from an LP‑PDL specification can be decomposed into a cascade product of localized automata. Each factor in the cascade operates on a single process and feeds its output to the next factor, thereby simulating the effect of a global coordinator without ever constructing one. This cascade decomposition not only yields a constructive proof of the theorem but also provides a clear architectural blueprint for implementing regular trace languages in a distributed setting.

A particularly elegant result is the implementation of the classic gossip automaton as a cascade of local automata. The gossip automaton traditionally requires every process to broadcast its entire local state to all others, leading to a quadratic communication overhead. By expressing the gossip protocol in LP‑PDL and then applying the translation, the authors obtain a sequence of simple local automata that collectively achieve the same information dissemination. Each automaton only forwards information that it has already learned, and the cascade order guarantees that eventually every process obtains the full global view. This construction demonstrates that the seemingly global nature of gossip can be reduced to a composition of purely local behaviors.

The paper concludes with a discussion of practical implications. Because LP‑PDL specifications translate directly into asynchronous automata whose structure reflects the original formula, model‑checking and synthesis tools can exploit this correspondence to generate implementations that are both correct by construction and efficiently executable. The locality property also enables modular verification: one can verify each local component independently and then compose the results using the cascade product, dramatically reducing the state‑space explosion typical of concurrent verification.

In summary, the authors present a clean, locally‑oriented past PDL that is expressively complete for regular trace languages, provide an efficient, structure‑preserving translation to asynchronous automata, and leverage this machinery to give new proofs of Zielonka’s theorem and to implement gossip automata as cascade products. These contributions refine and simplify earlier work, offering both theoretical insight and concrete tools for the design and verification of distributed systems.