Abstract 1 Introduction 2 Preliminaries 3 Algebra to temporal logic 4 Logic to cascade products to algebra 5 Results on related fragments References

Characterizations of Fragments of Temporal Logic over Mazurkiewicz Traces

Bharat Adsul ORCID IIT Bombay, Mumbai, India Paul Gastin ORCID Université Paris-Saclay, ENS Paris-Saclay, CNRS, LMF, 91190, Gif-sur-Yvette, France
CNRS, ReLaX, IRL 2000, Siruseri, India
Shantanu Kulkarni ORCID IIT Bombay, Mumbai, India
Abstract

We study fragments of temporal logics over Mazurkiewicz traces which are well known and established partial-order models of concurrent behaviours. We focus on concurrent versions of “strict past” and “strict future” modalities. Over words, the corresponding fragments have been shown to coincide with natural algebraic conditions on the recognizing monoids. We provide non-trivial generalizations of these classical results to traces. We exploit the local nature of the temporal modalities and obtain modular translations of specifications into asynchronous automata. More specifically, we provide novel characterizations of these fragments via local cascade products of a very simple two-state asynchronous automaton operating on a single process.

Keywords and phrases:
Mazurkiewicz traces, temporal logics, asynchronous automata, cascade product, Green’s relations, algebraic automata theory
Copyright and License:
[Uncaptioned image] © Bharat Adsul, Paul Gastin, and Shantanu Kulkarni; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation → Modal and temporal logics
; Theory of computation → Distributed computing models ; Theory of computation → Algebraic language theory ; Security and privacy → Logic and verification
Editors:
Patricia Bouyer and Jaco van de Pol

1 Introduction

Temporal logics are widely used logical formalisms to reason about properties of computations. Words serve as temporal models of sequential computations/behaviours and linear temporal logic LTL formulas use natural future as well as past temporal modalities to talk about interesting patterns of these behaviours. The celebrated theorem of Kamp [16] showed that, over words, properties definable in LTL coincide with those definable in the first order (FO) logic. By the seminal results of McNaughton-Papert [18] and Schutzenberger [20], these also equal regular languages describable by star-free regular expressions and those recognized by finite aperiodic monoids.

The above mentioned results clearly indicate the important role played by the temporal modalities in the very rich expressive power of LTL. Natural and commonly used temporal modalities include future modalities 𝖷 (“neXt/tomorrow”), 𝖥 (“Future”), 𝖴 (“Until”), the past counterparts 𝖸 (“previous/Yesterday”), 𝖯 (“Past”), 𝖲 (“Since”) and their strict variants such as 𝖷𝖥 (“strict future”) and 𝖸𝖯 (“strict past”). Several works [7],[14],[5] have studied natural fragments of LTL obtained by allowing only some of these modalities and have characterized these fragments in terms of algebraic conditions on the recognizing finite monoids. These algebraic characterizations have been crucially used to show that the computational problems of definability in the associated fragments are decidable.

Let us consider the fragment 𝖫𝖳𝖫⁢[𝖸𝖯] obtained by allowing only unary strict past modality 𝖸𝖯. When interpreted over words, the formula 𝖸𝖯 φ, at a given position, asserts that φ holds at some position in the strict past (that is, strictly left) of the current position. It has been shown in [6],[7],[14],[5] that a language is definable in 𝖫𝖳𝖫⁢[𝖸𝖯] iff it can be recognized by a ℛ-trivial monoid iff the syntactic monoid of the language is ℛ-trivial. Here ℛ stands for one of fundamental Green’s relations on a monoid. The ℛ-triviality condition on a monoid M simply means that if two elements of M are right multiples of each other then they are equal (that is, for all m,n∈M, ∃p,q∈M:n=m⋅p⁢ and ⁢m=n⋅q implies m=n). This characterization can also be stated in simpler automata-theoretic terms [6]. A finite-state automaton is said to be partially ordered if there is a partial order ⪰ on the states so that every transition is of the form (p,a,q) where p⪰q. Said differently, an automaton is partially ordered iff the only cycles present in the underlying directed transition graph are self loops. Using this notion, the above mentioned characterization can be stated as follows: a language is 𝖫𝖳𝖫⁢[𝖸𝖯]-definable iff it can be accepted by a partially ordered automaton.

It turns out that the dual fragment 𝖫𝖳𝖫⁢[𝖷𝖥] which admits the unary strict future modality 𝖷𝖥 is characterized by the dual condition of ℒ-triviality. As expected, a monoid is ℒ-trivial if no two distinct elements can be left multiples of each other. The fragment 𝖫𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] which includes both 𝖷𝖥 and 𝖸𝖯 modalities has been well studied and is known to coincide with important first order logic fragments, namely, F⁢O2 and Δ2. It also has an algebraic characterization in terms of monoids from the class DA. See the survey [9] for more details.

In this work we study the above mentioned temporal logic fragments from the concurrency viewpoint. We consider Mazurkiewicz traces as the underlying models of concurrent behaviours. A Mazurkiewicz trace or simply trace, over a set of processes, represents a concurrent behaviour as a labelled partial-order between events. This partial-order between events faithfully captures the causal information flow among processes. Traces are extensively studied and there is a rich theory of regular trace languages [23],[12]. Regular trace languages are known to coincide with MSO-definable languages as well as languages recognized by finite monoids. We consider natural event-based interpretations of temporal modalities 𝖷𝖥 and 𝖸𝖯 over traces. For instance, the formula 𝖸𝖯 φ, at a given event, asserts that φ holds at an event which is in the strict causal past of the current event. We denote by 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] the local/event-based temporal logic over traces which has access to the temporal modality 𝖸𝖯. One can similarly define 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] and 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯]. One of our main results states that a trace language is definable in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] iff it can be recognized by a ℛ-trivial monoid. This can be viewed as a non-trivial generalization of the corresponding result over words. We also obtain an analogous algebraic characterization of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] in terms of ℒ-trivial monoids. An algebraic characterization of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] in terms of monoids from the class DA already appears in [17].

Another important contribution of this work is a modular translation of formulas in these fragments into asynchronous automata. In an asynchronous automaton, each process runs a finite local-state device and these devices synchronize with each other on shared actions. Asynchronous automata can be naturally used to accept trace languages. Zielonka’s theorem states that regular trace languages are precisely the languages accepted by asynchronous automata. As in [19, 2, 3], one can use asynchronous automata as transducers on traces, similar in spirit to the sequential letter-to-letter transducers on words. Unlike these works which use deterministic asynchronous transducers to locally compute relabelling functions on input traces, we allow non-deterministic asynchronous transducers. As expected, these transducers compute relabelling relations from input traces to output traces. The local cascade product of deterministic asynchronous automata (or transducers) from [2, 3] is a natural generalization of cascade product in the sequential setting [21]. It further extends naturally to the non-deterministic setting and corresponds to compositions of related relabelling relations.

We use this machinery to provide a translation (in fact, a characterization) of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] formulas into local cascade products of very simple two-state asynchronous automata operating on a single process. For 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] formulas, the resulting atomic two-state transducers are deterministic while for 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] formulas, they are reverse-deterministic. We remark that our results and their proofs for traces specialize to the setting of words.

The rest of the paper is organized as follows. After setting up the preliminary notions in Section 2, we establish in Section 3 that ℛ-trivial trace languages are definable in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯]. In Section 4, we provide a translation of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] formulas into cascade products of localized deterministic asynchronous transducers/automata whose transition monoid is isomorphic to U1 - the unique two element aperiodic monoid. Section 5 is devoted to dual results concerning ℒ-trivial and 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥]-definable trace languages. We also sketch a cascade product based characterization of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] in this section.

2 Preliminaries

In this section, we set up the notation and review basics of traces. We also recall the recognizability of trace languages by morphisms into monoids and define the fundamental Green’s relations on monoids.

2.1 Trace basics

Let 𝒫 be a finite, non-empty set of processes. For every process i∈𝒫, Σi is the set of letters/actions in which process i participates. A distributed alphabet over 𝒫 is the family Σ~={Σi}i∈𝒫 with Σ=∪i∈𝒫Σi being the associated total alphabet. Letters a,b∈Σ are dependent if there is a process which participates in both of them (∃i∈𝒫, a,b∈Σi), otherwise they are independent. For a letter a∈Σ we define 𝗅𝗈𝖼⁢(a)={i∈𝒫∣a∈Σi} to be the set of processes that participate in a.

A poset is a tuple (E,≤) with E being the underlying set and ≤ being the partial order on E. A Σ-labelled poset over Σ~ is a triple (E,≤,λ) where (E,≤) is the underlying poset, and λ:E→Σ is the labelling function which labels each element in E with a letter from Σ. For elements e,e′∈E, e′ is said to be an immediate successor of e, denoted by e⋖e′, if e is below e′ (e<e′) and there is no event f strictly between e and e′ (∄⁢f∈E, e<f<e′).

A (Mazurkiewicz) trace t=(E,≤,λ) over Σ~ is a finite Σ-labelled poset with λ satisfying the following two properties:

  1. 1.

    for e,e′∈E, if e⋖e′, then λ⁢(e) and λ⁢(e′) are dependent;

  2. 2.

    for e,e′∈E, if λ⁢(e) and λ⁢(e′) are dependent, then they are ordered (e≤e′ or e′≤e).

For a trace t=(E,≤,λ) we sometimes slightly abuse notation to say event e∈t which we take to mean that event e∈E. The set of process i-events in t is defined as Ei={e∈E∣λ⁢(e)∈Σi}. Note that Ei is totally ordered by ≤. For an event e∈t, we slightly abuse the notation and define 𝗅𝗈𝖼⁢(e)=𝗅𝗈𝖼⁢(λ⁢(e)) to be the set of processes that participate in e. For an event e we define ↓e={f∈t∣f≤e} to be the set of events in t below e. Similarly ⇓e={f∈t∣f<e} is the set of events in t strictly below e. It is easy to see that by restricting ≤ and λ to events in ↓e, we obtain a valid trace. By abuse of notation, we denote this trace by (↓e,≤,λ) or simply ↓e. It will be clear from the context whether we mean ↓e to be a trace or merely a set of events. Similarly, ⇓e also refers to the trace (⇓e,≤,λ) induced by ⇓e.

The set of all finite traces over Σ~ is denoted by T⁢R⁢(Σ~). We define the trace concatenation operation ⋅ on T⁢R⁢(Σ~) as follows. Let t1=(E1,≤1,λ1),t2=(E2,≤2,λ2)∈T⁢R⁢(Σ~) with E1∩E2=∅. We define t1⋅t2 or simply t1⁢t2 to be the trace (E1∪E2,≤,λ)∈T⁢R⁢(Σ~) where:

  1. 1.

    ≤ is the transitive closure of ≤1∪≤2∪{(e1,e2)∈E1×E2∣λ1(e1),λ2(e2) are dependant}.

  2. 2.

    For all e∈E1∪E2, λ⁢(e)=λ1⁢(e)⁢ if ⁢e∈E1⁢ and ⁢λ2⁢(e)⁢ if ⁢e∈E2.

A trace t′ is said to be a prefix of trace t if there exists t′′∈T⁢R⁢(Σ~) such that t=t′⁢t′′. It is easy to see that, for e∈t, ↓e and ⇓e are both prefixes of t.

2.2 Recognizable trace languages

Recall that a monoid is a set M equipped with a binary associative operation ⋅ and containing an identity element 1M, such that ∀m∈M, m⋅1M=1M⋅m=m. The set T⁢R⁢(Σ~), under the operation of trace concatenation, is a monoid with the empty trace ε as the identity element. Let M and N be two monoids with operations ⋅ and ∘ respectively. A morphism h from M to N is a map h:M→N such that: h⁢(1M)=1N and for all m1,m2∈M, h⁢(m1⋅m2)=h⁢(m1)∘h⁢(m2).

A subset L⊆T⁢R⁢(Σ~) is called a trace language over Σ~. We call a morphism from the trace monoid T⁢R⁢(Σ~) to any other monoid M as a trace morphism. A trace language L⊆T⁢R⁢(Σ~) is recognizable if there exists a trace morphism h from T⁢R⁢(Σ~) to a finite monoid M such that L=∪m∈Ph−1⁢(m) for some P⊆M. We may refer to h as the recognizing morphism or say that L is recognized by M via recognizing morphism h. The class of recognizable trace languages, also referred to as regular trace languages, has several characterizations and we note a few in particular, namely MSO-definable languages over traces [22] and trace languages accepted by asynchronous automata [23].

Classically, the algebraic viewpoint in terms of what are known as Green’s relations over monoids has been fruitful for characterizing interesting subclasses of regular languages which have an intimate connection with logics. We now briefly recall these fundamental Green’s preorders and the associated equivalence relations.

Let M be a monoid with ⋅ as the binary monoid operation and let m1,m2∈M. The Green’s preorder relations are defined as follows:

  1. 1.

    m1≤Rm2 (read as m1 is R-below m2) if there exists m∈M such that m1=m2⋅m.

  2. 2.

    m1≤Lm2 if there exists m∈M such that m1=m⋅m2.

  3. 3.

    m1≤Jm2 if there exist u,v∈M such that m1=u⋅m2⋅v

  4. 4.

    m1≤Hm2 if m1≤Rm2 and m1≤Lm2

These preorders naturally give rise to the associated equivalence relations ℛ,ℒ,𝒥,ℋ. We say that m1ℛm2 (read as m1 is ℛ-equivalent to m2) if m1≤Rm2 and m2≤Rm1. A monoid M is ℛ-trivial if ∀m1,m2∈M, m1ℛm2 implies m1=m2. In other words, M is ℛ-trivial iff the preorder ≤R on M is in fact a partial order on M iff the equivalence relation ℛ coincides with the identity relation on M.

The other equivalence relations ℒ,𝒥,ℋ and their triviality for M are defined analogously. A trace language L⊆T⁢R⁢(Σ~) is called ℛ-trivial if it can be recognized by a finite ℛ-trivial monoid. One can similarly define ℒ-trivial, 𝒥-trivial and ℋ-trivial trace languages.

Example 1.

Consider the monoid U1={1,0} with 1 as the identity and 0 as the zero element. So, 1⋅1=1, 0⋅1=1⋅0=0⋅0=0. It is easily checked that U1 is ℛ-trivial, ℒ-trivial, 𝒥-trivial as well as ℋ-trivial.

As mentioned in the introduction, for word languages, ℛ-triviality (ℒ-triviality) corresponds to definability in LTL with only the strict past (respectively strict future) modality. See [5] for a proof based on Green’s relations. It turns out that, for finite monoids,ℋ-triviality condition is equivalent to the aperiodicity property. As a consequence, ℋ-trivial word languages coincide with languages definable in the first order logic and linear temporal logic. These results find interesting generalizations over traces in [15, 13, 8].

3 Algebra to temporal logic

We now state our main theorem and set up the technical machinery and prove it.

Theorem 2.

Let L⊆T⁢R⁢(Σ~). Then the following are equivalent.

  1. 1.

    L is a ℛ-trivial trace language.

  2. 2.

    L can be expressed using a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯].

  3. 3.

    L can be accepted by a cascade product of localized U1 asynchronous automata.

Proof.

1→2 is shown in Theorem 14, 2→3 is shown in Theorem 22, 3→1 is shown in Theorem 24. ◀

The result we wish to prove in this section is the 1→2 for Theorem 2, which says that any trace language which is recognized by a ℛ-trivial monoid can be expressed as a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯]. This statement is restated as Theorem 14. We start by defining formally the syntax and semantics of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯].

3.1 𝗟𝗼𝗰𝗧𝗟⁢[𝗬𝗣] syntax and semantics

We now define 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯]. We have sentences Φ, which are evaluated over finite Mazurkiewicz traces and hence define languages over T⁢R⁢(Σ~) and also event formulas φ which are evaluated at a given event in a trace. The syntax is as follows:

Φ ::=𝖤φ∣Φ1∨Φ2∣¬Φ
φ ::=a∣φ1∨φ2∣¬φ∣𝖸𝖯φ

The semantics for the boolean operations are as usual. For a trace t=(E,≤,λ) and an event e∈E, the following defines the semantics of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯]

t ⊧𝖤φ if there exists an event e in t such that t,e⊧φ
t,e ⊧a if λ⁢(e)=a
t,e ⊧𝖸𝖯φ if there exists an event f in t with f<e and t,f⊧φ.

In the rest of the paper we shall use the following macros liberally:

𝖠φ =¬𝖤¬φ, 𝖯φ =φ∨𝖸𝖯φ,
𝖸𝖧φ =¬𝖸𝖯¬φ, 𝖧φ =φ∧𝖸𝖧φ.

The modalities can be read as Exists (𝖤), All (𝖠), Past (𝖯), Historically (𝖧), Yesterday Past (𝖸𝖯), Yesterday Historically (𝖸𝖧). For a set of letters A, we may abuse notation and use A to denote the event formula ⋁a∈Aa testing whether the event is labelled by a letter in A. For instance, we may use Σi as the macro for the event formula ⋁a∈Σia which tests whether the current event is an i-event.

Example 3.

Let t∈T⁢R⁢(Σ~) be a trace and e∈t be an event. We design an event formula φki such that t,e⊧φki iff there are at least k process i-events strictly below event e. We define φki inductively as: φ0i=⊤ and for k>0, φki=𝖸𝖯(Σi∧φk−1i). Consider the 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] sentence Φm,n=𝖤(Σj∧φn−1j∧¬φnj∧φmi). Clearly Φm,n has the property that trace t satisfies Φm,n if and only if the mt⁢h process i-event is strictly below the nt⁢h process j-event.

3.2 Critical structures for a morphism into a 𝓡-trivial monoid

Throughout the rest of this section, we fix a morphism h:T⁢R⁢(Σ~)→M to a fixed finite ℛ-trivial monoid M.

Let t=(E,≤,λ) be a trace and e∈E be an event of t. Note that, viewing ↓e and ⇓e as traces, we have h(↓e)=h(⇓e)h(λ(e))≤Rh(⇓e). The event e is said to be a critical event in t if h(↓e)≠h(⇓e). Since the monoid M is ℛ-trivial, this is equivalent to h(↓e)<Rh(⇓e). We let Xt={e∈E∣h(↓e)<Rh(⇓e)} be the set of all critical events of trace t.

Lemma 4.

In the above notation, |Xt|<|𝒫|×|M|.

Proof.

We show that the number of critical events on a single process line is less than |M|. This clearly implies that |Xt| is less than |𝒫|×|M|. For any i∈𝒫, the set of critical process i events is Xt∩Ei. Assume Xt∩Ei={e1,e2,⋯⁢ek} with e1<e2<⋯<ek (Ei is totally ordered by ≤). Since ej are critical events we have h(↓ej)<Rh(⇓ej). Since (the trace induced by) ↓ej is a prefix of (the trace induced by) ⇓ej+1, we have h(⇓ej+1)≤Rh(↓ej). We get

h(↓ek)<Rh(⇓ek)≤Rh(↓ek−1)<Rh(⇓ek−1)≤R⋯⁢h(↓e1)<Rh(⇓e1)≤R1M.

Therefore k<|M| which concludes the proof. ◀

A configuration of t is a subset C⊆E of events which is downward closed: C=↓C. Clearly, for any event e∈E, ↓e and ⇓e are configurations of t. We sometimes abuse the notation and use C to also denote the trace induced by a configuration C of t. It is easy to see that t=C⋅t′ where t′ is the trace induced by the set E∖C of events of t which do not belong to C.

A configuration C of t is critical if for every maximal event e∈C, we have h⁢(C)≠h⁢(C∖{e}), equivalently, h⁢(C)<Rh⁢(C∖{e}). Note that if e is a maximal event of C then C∖{e} is a configuration of t.

Lemma 5.

Every maximal event of a critical configuration is a critical event.

Proof.

Suppose for contradiction that there exists a critical configuration C and a maximal event e∈C such that h⁢(C)<Rh⁢(C∖{e}) but h(↓e)=h(⇓e). We have that h(C)=h(↓e)⋅h(C∖↓e). Substituting h(↓e) by h(⇓e), we get h(C)=h(⇓e)⋅h(C∖↓e)=h(C∖{e}) giving us a contradiction to the fact that h⁢(C)≠h⁢(C∖{e}). ◀

Example 6.

A configuration in which every maximal event is critical, may not itself be critical. We show this via an example. Consider three processes and the distributed alphabet defined by Σ1={a}, Σ2={b} and Σ3={c} (each process has a local action). Consider the ℛ-trivial (commutative) monoid M=({0,1,2},⊕,0) with truncated sum defined as x⊕y=min⁡(2,x+y). In other words, 0 is the neutral element, 2 is absorbent, and 1⊕1=2. We have 2<R1<R0. Consider the (truncated) length trace morphism h:T⁢R⁢(Σ~)→M defined by h⁢(x)=1 for all x∈Σ. Finally, let t=a⁢b⁢c=(E,≤,λ) be the trace with 3 events labelled a, b and c respectively. Each event e in t is critical and is maximal in t. But the configuration E is not critical since for each e∈E, we have h⁢(E∖{e})=2=h⁢(E).

Lemma 7.

Any prefix t′ of t containing all the critical events of t, evaluates to the same monoid value as t under h. In other words, we have h(↓Xt)=h⁢(t).

Proof.

We have h⁢(t)≤Rh(↓Xt) since ↓Xt is a prefix of t. For the converse, we first show that there exists a critical configuration C of t=(E,≤,λ) such that h⁢(C)=h⁢(t). The configuration C=E satisfies h⁢(C)=h⁢(t). Let C be a configuration with h⁢(C)=h⁢(t). Either C is critical and we are done, or we can drop a maximal event from C to get a strictly smaller configuration C′ satisfying h⁢(C′)=h⁢(t). Repeating this, we find a critical configuration C of t such that h⁢(C)=h⁢(t). By Lemma 5, the maximal events of C are critical. Hence we get C⊆↓Xt. This implies h(↓Xt)≤Rh⁢(C)=h⁢(t). By ℛ-triviality, we deduce h(↓Xt)=h⁢(t). ◀

The type of a trace t=(E,≤,λ) is the Σ-labelled poset 𝗍𝗒𝗉𝖾⁢(t)=(Xt,≤,λ) obtained as the restriction of the labelled poset (E,≤,λ) to the critical events of t.

Example 8.

It is important to note that the type of a trace need not necessarily be a trace itself. Let t=a⁢b⁢c be a trace over the distributed alphabet Σ1={a,b}, Σ2={b,c} with 3 events e1<e2<e3 labelled a, b, c respectively, as shown in the figure below. Consider the ℛ-trivial (commutative) monoid M=({1,2,3},max,1) where max is the binary maximum operation. It is clear that 3<R2<R1. Consider the trace morphism h:T⁢R⁢(Σ~)→M defined by h⁢(a)=2, h⁢(b)=1 and h⁢(c)=3. We see that only e1 and e3 are critical events of t. Then, 𝗍𝗒𝗉𝖾⁢(t)=({e1,e3},≤,λ) with e1<e3 which is induced by the original partial order on t. Since the labels a and c are independent, 𝗍𝗒𝗉𝖾⁢(t) is not a trace.

Let s=(Z,≤,λ) be a Σ-labelled poset. A linearization of s is a word111A word a1⁢a2⁢⋯⁢an∈Σ∗ is identified with the structure ({e1,e2,…,en},⪯,λ) with λ⁢(ei)=ai and e1≺e2≺⋯≺en. w=(Z,⪯,λ) where ⪯ is a total order on Z which is consistent with ≤, that is, satisfying ≤⁣⊆⁣⪯. We denote by 𝖫𝗂𝗇⁢(s)⊆Σ∗ the set of linearizations of s.

Let h′:Σ∗→M be the word morphism defined by h′⁢(a)=h⁢(a) for all a∈Σ. For all traces t∈T⁢R⁢(Σ~) and for all linearizations w∈𝖫𝗂𝗇⁢(t), we have h′⁢(w)=h⁢(t).

For every monoid element m∈M we define Σm={a∈Σ∣m⋅h⁢(a)=m} as the set of letters stabilizing m. The complement Σ∖Σm={a∈Σ∣m⋅h⁢(a)≠m} also denoted Σm¯ is the set of letters which cause an ℛ-descent for m. This means that for every a∈Σm¯ m⋅h⁢(a)<Rm.

Lemma 9.

Let t=(E,≤,λ) be a trace and 𝗍𝗒𝗉𝖾⁢(t)=(Xt,≤,λ) be its type. For all linearizations w∈𝖫𝗂𝗇⁢(𝗍𝗒𝗉𝖾⁢(t)), we have h′⁢(w)=h⁢(t).

Proof.

The proof is by induction on the number k=|Xt| of critical events of t.

For the base case k=0 there are no critical events in t. This means that w=ε and all events in t have labels in Σ1M. Clearly, we have h′⁢(ε)=1M=h⁢(t).

Assume now k>0 and that the result holds for all traces s with |Xs|<k. Consider the linearization w=a1⁢a2⁢⋯⁢ak∈𝖫𝗂𝗇⁢(𝗍𝗒𝗉𝖾⁢(t)). We have w=(Xt,⪯,λ) with Xt={e1,e2,…,ek}, e1≺e2≺⋯≺ek and λ⁢(ei)=ai. Note that the event ek is maximal in ↓Xt. Consider the trace s which is the prefix of t induced by (↓Xt)∖{ek}. It is easy to see that 𝗍𝗒𝗉𝖾⁢(s)=({e1,…,ek−1},≤,λ) and v=a1⁢⋯⁢ak−1∈𝖫𝗂𝗇⁢(𝗍𝗒𝗉𝖾⁢(s)). By induction, we have h′⁢(v)=h⁢(s). Therefore, h′⁢(w)=h′⁢(v)⋅h′⁢(ak)=h⁢(s)⋅h⁢(λ⁢(ek))=h(↓Xt)=h⁢(t) where the last equality follows from Lemma 7. ◀

It follows immediately that the type of a trace determines its value under h.

Corollary 10.

Let t,t′∈T⁢R⁢(Σ~) be two traces. If 𝗍𝗒𝗉𝖾⁢(t) and 𝗍𝗒𝗉𝖾⁢(t′) are isomorphic, denoted 𝗍𝗒𝗉𝖾⁢(t)≅𝗍𝗒𝗉𝖾⁢(t′), then h⁢(t)=h⁢(t′).

We conclude this subsection with some more definitions. Recall that we have fixed the distributed alphabet Σ~ and the morphism h from T⁢R⁢(Σ~) to the finite ℛ-trivial monoid M. We define the type set of Σ~, with respect to h, to be the set of all possible types of all traces over Σ~. More precisely, 𝗍𝗒𝗉𝖾𝗌⁢(Σ~)={𝗍𝗒𝗉𝖾⁢(t)∣t∈T⁢R⁢(Σ~)}. Note that, it clearly depends on h. By Lemma 4, every type is a Σ-labelled poset whose underlying set has size less than |𝒫|×|M|. Therefore 𝗍𝗒𝗉𝖾𝗌⁢(Σ~) is a finite set.

By Corollary 10, the type of a trace determines its monoid value under the recognizing morphism h. Hence we can define a function π:𝗍𝗒𝗉𝖾𝗌⁢(Σ~)→M by π⁢(𝗍𝗒𝗉𝖾⁢(t))=h⁢(t) for all t∈T⁢R⁢(Σ~). Note that, by Lemma 9, if σ=(X,≤,λ) is a type then π⁢(σ)=h′⁢(w) for all w∈𝖫𝗂𝗇⁢(σ).

Let t=(E,≤,λ) be a trace and e∈E be an event. The type of e in t is the type of the prefix of t induced by the strict past of e: 𝗍𝗒𝗉𝖾⁢(t,e)=𝗍𝗒𝗉𝖾(⇓e)=(X⇓e,≤,λ)=(Xt∩⇓e,≤,λ). We have π⁢(𝗍𝗒𝗉𝖾⁢(t,e))=h(⇓e).

Lemma 11.

Let t=(E,≤,λ) be a trace and e,f be events in t. If 𝗍𝗒𝗉𝖾⁢(t,e)=𝗍𝗒𝗉𝖾⁢(t,f)=σ and λ⁢(e)=λ⁢(f)∈Σm¯ where m=π⁢(σ) then e=f.

Proof.

Assume towards a contradiction that there are two events e,f in t with 𝗍𝗒𝗉𝖾⁢(t,e)=𝗍𝗒𝗉𝖾⁢(t,f)=σ and λ⁢(e)=λ⁢(f)=a∈Σm¯ where m=π⁢(σ). Without loss of generality we may assume e<f since they are both labelled with the same letter and hence are ordered. Then, e is a critical event: indeed, 𝗍𝗒𝗉𝖾⁢(t,e)=σ hence h(⇓e)=π⁢(σ)=m and λ⁢(e)=a∈Σm¯ implies that h(↓e)=m⋅h⁢(a)≠m. We deduce that X⇓e∪{e}⊆X⇓f: there are more critical events in the strict past of f than in the strict past of e. This is a contradiction with 𝗍𝗒𝗉𝖾⁢(t,e)=𝗍𝗒𝗉𝖾⁢(t,f). ◀

3.3 Proof of Theorem 2 [𝟏→𝟐]

Having done the necessary setup we now prove the first direction of Theorem 2 (restated as Theorem 14 at the end of this subsection). We start with Lemma 12 which supplies the key argument by constructing 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] event formulas for identifying the type of an event.

An event formula φ of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] is called a strict past formula if it is a boolean combination of formulas of the form 𝖸𝖯φ′. A strict past formula does not test the label of the current event.

Lemma 12.

For every σ∈𝗍𝗒𝗉𝖾𝗌⁢(Σ~), there exists a strict past event formula φσ such that, for all traces t=(E,≤,λ)∈T⁢R⁢(Σ~) and all events e in t, t,e⊧φσ iff 𝗍𝗒𝗉𝖾⁢(t,e)≅σ.

Proof.

We construct φσ by induction and prove that it has the correct property.
Base case: |σ|=0, i.e., σ=(∅,∅,∅). Note that π⁢((∅,∅,∅))=1M=h⁢(ε) where ε is the empty trace. We define φσ=𝖸𝖧(Σ1M). We now prove that it has the desired property.

If t,e⊧𝖸𝖧(Σ1M) then every letter in the strict past of e stabilizes the monoid identity element. We deduce easily that there are no critical events in the strict past of e. Therefore 𝗍𝗒𝗉𝖾⁢(t,e)=(∅,∅,∅).

Conversely, if 𝗍𝗒𝗉𝖾⁢(t,e)=(∅,∅,∅) then there are no critical events in the strict past of e. Since the empty trace is the smallest prefix of a trace and it maps to 1M under h, we deduce easily that every letter in the strict past of e must stabilize the monoid identity 1M. Therefore t,e⊧𝖸𝖧(Σ1M).
Induction hypothesis: Let k≥0 and assume that for every type σ with |σ|≤k, we have constructed φσ satisfying the property of the lemma. Consider an arbitrary type τ∈𝗍𝗒𝗉𝖾𝗌⁢(Σ~) of size k+1. We construct φτ below and prove its correctness.

Let s=(Es,≤s,λs)∈T⁢R⁢(Σ~) be a trace with τ=𝗍𝗒𝗉𝖾⁢(s)=(Xs,≤s,λs). For an element x∈Xs, we let τx=(⇓τx,≤s,λs) be the restriction of the labelled poset τ to the critical events strictly below x (⇓τx={y∈Xs∣y<sx}). It is easy to see that τx=𝗍𝗒𝗉𝖾⁢(s,x)=𝗍𝗒𝗉𝖾(⇓sx) where ⇓sx={e∈Es∣e<sx} is (the prefix of s induced by) the strict past of x in s. Let mx=h(⇓sx)=π⁢(τx) and ax=λs⁢(x). Since x∈Xs is a critical event of s, we have h(↓sx)=h(⇓sx)⋅h(λs(x))=mxh(ax)<Rmx=h(⇓sx). Therefore, ax∈Σmx¯=Σπ⁢(τx)¯.

Notice that the size of τx∈𝗍𝗒𝗉𝖾𝗌⁢(Σ~) is at most k. By induction hypothesis, we have a formula φτx satisfying the property of the lemma. We use the macro φ⁢(τ,x) to denote the event formula φτx∧ax. Finally, if Z⊆Xs, we let τZ=(↓τZ,≤s,λs). Then, τZ=𝗍𝗒𝗉𝖾(↓sZ) is a type and we let mZ=π⁢(τZ)=h(↓sZ). We define

φτ =φ1∧φ2∧φo⁢r⁢d⁢e⁢r φ1 =𝖸𝖧(φc⁢r⁢i⁢t∨φs⁢t⁢a⁢b)
φ2 =⋀x∈Xs𝖸𝖯φ⁢(τ,x) φc⁢r⁢i⁢t =⋁x∈Xsφ⁢(τ,x)
φo⁢r⁢d⁢e⁢r =⋀x,y∈Xs∣x<sy𝖸𝖯(φ⁢(τ,y)∧𝖸𝖯φ⁢(τ,x))∧⋀x,y∈Xs∣x≮sy¬𝖸𝖯(φ⁢(τ,y)∧𝖸𝖯φ⁢(τ,x))
φs⁢t⁢a⁢b =⋁Z⁣=⁣↓τZ⁣⊆XsΣmZ∧⋀x∈Z𝖸𝖯φ⁢(τ,x)∧⋀x∈Xs∖Z¬𝖸𝖯φ⁢(τ,x)

Before proceeding to the formal proof of correctness of φτ, we first provide an intuitive explanation of the various parts of φτ.

  • ■

    φ2: asserts that for every “event” x in τ, there is a (unique) corresponding critical event in the strict past whose type is isomorphic to τx and whose label is same as that of x.

  • ■

    φ1: asserts that every event in the strict past either corresponds to some “event” x in τ (satisfies φc⁢r⁢i⁢t) or is labelled with a stabilizing letter for the type Z arising out of the “events” x in τ

  • ■

    φo⁢r⁢d⁢e⁢r: asserts that the ordering between “events” in τ and the corresponding critical events is identical.

We now formally show that φτ indeed satisfies the property of the lemma. Towards this, fix a trace t=(Et,≤t,λt) and an event e in t.

(→) Assume that t,e⊧φτ. We show that 𝗍𝗒𝗉𝖾⁢(t,e)≅τ.

First consider the fact that t,e⊧φ2. This means that for all x∈Xs, there exists an event ex∈⇓te, such that t,ex⊧φ⁢(τ,x). By the inductive hypothesis, we have τx≅𝗍𝗒𝗉𝖾⁢(t,ex)=𝗍𝗒𝗉𝖾(⇓tex) and λt⁢(ex)=ax∈Σmx¯. From Lemma 11, ex is the unique event in t satisfying φ⁢(τ,x). Using h(⇓tex)=π⁢(τx)=mx and λt⁢(ex)=ax∈Σmx¯, we deduce that ex is critical in ⇓te. Therefore, Y={ex∣x∈Xs}⊆X⇓te.

Now, using the fact that t,e⊧φo⁢r⁢d⁢e⁢r and the unicity of the events ex, we deduce that for all x,y∈Xs, we have x≤sy if and only if ex≤tey. We also know that for all x∈Xs, we have λs⁢(x)=ax=λt⁢(ex). Therefore, τ≅(Y,≤t,λt).

In order to obtain τ≅𝗍𝗒𝗉𝖾⁢(t,e)=(X⇓te,≤t,λt) as desired, it remains to prove that Y=X⇓te. Towards a contradiction, assume that this is not the case and consider a minimal event f∈X⇓te∖Y. Since t,e⊧φ1, we have t,f⊧φc⁢r⁢i⁢t∨φs⁢t⁢a⁢b. If t,f⊧φc⁢r⁢i⁢t then t,f⊧φ⁢(τ,x) for some x∈Xs and by the unicity constraint f=ex∈Y, a contradiction. Hence, t,f⊧φs⁢t⁢a⁢b and there is a downward closed set Z=↓τZ⊆Xs such that λt⁢(f)∈ΣmZ and ⇓tf∩Y={ex∣x∈Z}. By minimality of f, we get ⇓tf∩X⇓te=⇓tf∩Y={ex∣x∈Z}. We deduce that 𝗍𝗒𝗉𝖾⁢(t,f)=({ex∣x∈Z},≤t,λt)≅τZ and h(⇓tf)=mZ. Using λt⁢(f)∈ΣmZ we conclude that f is not critical, a contradiction.

(←) Conversely, assume that τ≅𝗍𝗒𝗉𝖾⁢(t,e). We show that t,e⊧φτ.

From the isomorphism between τ=(Xs,≤s,λs) and 𝗍𝗒𝗉𝖾⁢(t,e)=(X⇓te,≤t,λt) we get a one-one correspondence x∈Xs↦ex∈X⇓te such that for all x,y∈Xs we have x≤sy if and only if ex≤tey and λt⁢(ex)=λs⁢(x). We deduce that 𝗍𝗒𝗉𝖾⁢(t,ex)≅τx and λt⁢(ex)=ax for all x∈Xs. Therefore, t,ex⊧φ⁢(τ,x) for all x∈Xs and t,e⊧φ2.

Next, it is easy to check that t,e⊧φo⁢r⁢d⁢e⁢r using the unicity property (Lemma 11) and the fact that x<sy if and only if ex<tey for all x,y∈Xs.

Let f∈⇓te be an event in the strict past of e. Either f∈X⇓te is a critical event and f=ex for some x∈Xs. In this case, we get t,f⊧φ⁢(τ,x) and t,f⊧φc⁢r⁢i⁢t. Or f∈⇓te∖X⇓te is a non-critical event. Let Z={x∈Xs∣ex<f}. Then, Z=↓τZ is downward closed and using the unicity property we deduce that t,f⊧⋀x∈Z𝖸𝖯φ⁢(τ,x)∧⋀x∈Xs∖Z¬𝖸𝖯φ⁢(τ,x). Now, due to the fact that τ≅𝗍𝗒𝗉𝖾⁢(t,e) it is clear that τZ≅𝗍𝗒𝗉𝖾⁢(t,f). We deduce that mZ=π⁢(τZ)=h(⇓tf). Since f is not critical, we have λt⁢(f)∈ΣmZ. Therefore, t,f⊧φs⁢t⁢a⁢b. We have shown that t,e⊧φ1. ◀

Lemma 13.

For every element m∈M we can define a strict past event formula φm in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] such that for every trace t and event e of t, we have t,e⊧φm⁢ iff ⁢h(⇓e)=m.

Proof.

We define φm=⋁σ∈𝗍𝗒𝗉𝖾𝗌⁢(Σ~):π⁢(σ)=mφσ and show that it has the desired property.

Let t be a trace and e be an event in t. If t,e⊧φm then there exists some σ∈𝗍𝗒𝗉𝖾𝗌⁢(Σ~) such that π⁢(σ)=m and t,e⊧φσ. By Lemma 12, σ≅𝗍𝗒𝗉𝖾⁢(t,e)=𝗍𝗒𝗉𝖾(⇓e). By definition of π, we have h(⇓e)=π⁢(σ). As π⁢(σ)=m, we conclude that h(⇓e)=m. Now for the other direction assume h(⇓e)=m. By Lemma 12, t,e⊧φ𝗍𝗒𝗉𝖾⁢(t,e) and by definition of π, π⁢(𝗍𝗒𝗉𝖾⁢(t,e))=h(⇓e). As h(⇓e)=m, π⁢(𝗍𝗒𝗉𝖾⁢(t,e))=m and hence t,e⊧φm. ◀

Theorem 14.

Let L⊆T⁢R⁢(Σ~) be recognized by the morphism h:T⁢R⁢(Σ~)→M. Then there is a sentence ΦL of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] which defines L: for all traces t∈T⁢R⁢(Σ~), t⊧ΦL⇔t∈L.

Proof.

As L is recognized by h, there is a subset P⊆M such that L=h−1⁢(P). For each monoid element m∈M, we define below a sentence Φm of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] which defines the trace language h−1⁢(m): for all traces t we have t⊧Φm⇔h⁢(t)=m. The sentence defining L is ΦL=⋁m∈PΦm.

Let #∉Σ be a new letter. We extend the distributed alphabet Σ~ by making # an action shared by all processes: Σ~#={Σi∪{#}}i∈𝒫. For each trace t∈T⁢R⁢(Σ~), we consider the augmented trace t¯=t⋅#∈T⁢R⁢(Σ~#) obtained by adding a maximum event e# labelled # to t. Note that all processes participate in e# and t=⇓e#. Now by Lemma 13, we have a strict past event formula222Formally the formula φm may use #. We can take care of this by using ¬Σ wherever it occurs in the formula. φm, such that t¯,e#⊧φm⇔h(⇓e#)=m⇔h⁢(t)=m. We can now set Φm as the sentence obtained by replacing every outermost occurrence of 𝖸𝖯 in φm by 𝖤. It is easy to see that t⊧Φm iff t¯,e#⊧φm. As a result, t⊧Φm iff h⁢(t)=m. ◀

4 Logic to cascade products to algebra

In this section, we first introduce a localized version of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] namely 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] and show that both have the same expressive power. 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] is more suited for the direction 2→3 of Theorem 2 where we connect logic to cascade products of asynchronous automata. Subsequently, in Section 4.2 we introduce asynchronous devices and their cascade products and prove Theorem 22 in Section 4.3. Finally we show the 3→1 direction of Theorem 2 by connecting cascade products to algebra in Theorem 24.

4.1 𝗟𝗼𝗰𝗧𝗟⁢[𝗬𝗣𝗶] and its equivalence with 𝗟𝗼𝗰𝗧𝗟⁢[𝗬𝗣]

We define local modalities 𝖤i and 𝖸𝖯i for each process i∈𝒫 as follows:

𝖤iφ=𝖤(Σi∧φ)⁢ and ⁢𝖸𝖯iφ=Σi∧𝖸𝖯(Σi∧φ)

Let t be a trace and e be an event of t. It is clear that, t,e⊧𝖸𝖯iφ iff e is an i-event and there exists an i-event e′ in the strict past of e such that t,e′⊧φ. Further t⊧𝖤iφ iff there exists an i-event f of t such that t,f⊧φ.

We define 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] as a fragment of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] in which only above local modalities are allowed. More precisely, the syntax of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] logic is as follows:

Φ ::=𝖤iφ∣Φ1∨Φ2∣¬Φ
φ ::=a∣φ1∨φ2∣¬φ∣𝖸𝖯iφ
Lemma 15.

𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] and 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] express the same class of trace languages over Σ~.

Proof.

We only need to show how to express the modalities 𝖤 and 𝖸𝖯 of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] with the local modalities of 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂]. We have 𝖤φ=⋁i∈𝒫𝖤iφ.

For the strict past modality 𝖸𝖯 we use a well-known fact on traces. Let t=(E,≤,λ) be a trace and e,f be events in t. Then e<f if and only if there is a sequence of events e=e0<e1<e2<⋯<ek=f with 1≤k≤|𝒫| and for each 1≤j≤k, there is a process ij∈𝒫 such that ej−1,ej are both ij-events. It is easy to deduce from here that

𝖸𝖯φ=⋁i1,i2,…,ik∈𝒫1≤k≤|𝒫|𝖸𝖯ik⋯⁢𝖸𝖯i2𝖸𝖯i1φ.

This shows that 𝖸𝖯 modality can be expressed in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] and concludes the proof. ◀

▶ Remark 16.

Referring to the syntax and semantics from [1] (Section 2.2), it is clear that 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] is a sublogic of 𝖫𝗈𝖼𝖯𝖺𝗌𝗍𝖯𝖣𝖫. Indeed, let φ be a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] event formula and assume there exists an equivalent event formula φ¯ in 𝖫𝗈𝖼𝖯𝖺𝗌𝗍𝖯𝖣𝖫. Then 𝖸𝖯iφ is implemented with ⟨←i+⟩⁢φ¯ and 𝖤iφ is implemented with 𝖤𝖬i(⟨←i∗⟩⁢φ¯)

4.2 Asynchronous devices and cascade product

We now recall the model of asynchronous automata due to Zielonka [23].

A deterministic asynchronous automaton A over Σ~ (or simply over Σ) is a tuple A=({Si}i∈𝒫,{δa}a∈Σ,sin) where

  • ■

    for each i∈𝒫, Si is a finite non-empty set of local i-states.

  • ■

    for each a∈Σ, δa:Sa→Sa is a deterministic joint transition function where Sa=∏i∈𝗅𝗈𝖼⁢(a)Si is the set of a-states.

  • ■

    with S=∏i∈𝒫Si as the set of all global states, sin∈S is a designated initial global state.

Let s∈S be a global state. We can write s as (sa,s−a) where sa is the projection of s onto 𝗅𝗈𝖼⁢(a) and s−a is the projection onto 𝒫∖𝗅𝗈𝖼⁢(a). For any letter a∈Σ, we can extend the joint transition function δa:Sa→Sa to a global transition function Δa:S→S on global states as follows: Δa⁢((sa,s−a))=(δa⁢(sa),s−a). For a trace t∈T⁢R⁢(Σ~), we let Δε be the identity function on S, and define Δt:S→S as the composition Δt=Δa∘Δt′ when t=t′⁢a. Note that Δt is well defined, since for any pair (a,b) of independent letters, Δa∘Δb=Δb∘Δa. We denote by A⁢(t) the global state Δt⁢(sin) reached when A runs on t.

At this point we define the transition monoid M⁢(A) associated with the asynchronous automaton A. Let M⁢(A) be the finite set of functions {Δt∣t∈T⁢R⁢(Σ~)}. This set under the usual function composition operation is a monoid with Δε as it’s identity element.

For any asynchronous automaton A, if we fix some F⊆S to be the set of accepting global states then we say L⁢(A,F)={t∣A⁢(t)∈F} is the trace language accepted by A.

We also use asynchronous automata as letter-to-letter asynchronous transducers as in [19, 2, 3] which compute a relabelling function. Let Γ be a finite non-empty set. We can define a natural extended distributed alphabet, Σ×Γ~ by inheriting the distribution from Σ~ that is, 𝗅𝗈𝖼⁢((a,γ))=𝗅𝗈𝖼⁢(a). T⁢R⁢(Σ~) and T⁢R⁢(Σ×Γ~) are the set of traces over the original and extended distributed alphabets. A function θ:T⁢R⁢(Σ~)→T⁢R⁢(Σ×Γ~) is called a Γ-labelling function if, for every t=(E,≤,λ)∈T⁢R⁢(Σ~), θ⁢(t)=(E,≤,(λ,μ))∈T⁢R⁢(Σ×Γ~). A Γ-labelling function decorates each event e of the trace t with a label μ⁢(e) from Γ.

An asynchronous Γ-transducer over Σ~ (or simply Σ) is a tuple A^=(A,{μa}) where A=({Si},{δa},sin) is an asynchronous automaton and each μa (a∈Σ) is a map μa:Sa→Γ. We overload notation and use A^:T⁢R⁢(Σ~)→T⁢R⁢(Σ×Γ~) to also denote the Γ-labelling function computed by the transducer A^. For t=(E,≤,λ)∈T⁢R⁢(Σ~), we define A^⁢(t)=(E,≤,(λ,μ))∈T⁢R⁢(Σ×Γ~) such that, for every e∈E with λ⁢(e)=a, μ⁢(e)=μa⁢(sa) where s=A(⇓e).

An asynchronous automaton (resp. transducer) with local state sets {Si} is said to be localized at process i if all local state sets Sj with j≠i are singletons. It is localized if it is localized at some process. For an automaton/transducer localized at i, all non-trivial transitions are on letters in which process i participates.

Figure 1: U1⁢[i] automaton.
Example 17.

We define U1⁢[i] to be a deterministic asynchronous automaton which is localized at process i. In U1⁢[i], the local state set of process i has two states: Si={1,2} while all other processes have a single state. In Figure 1 we show the local automaton for process i, which operates only on Σi=Σi1⊎Σi2. Note that, a letter in Σi2 allows to change the local state from 1 to 2 while the rest of the transitions are self-loops. Clearly, we can identify the global-states of U1⁢[i] with Si. With this convention, we always use 1 as the initial global state for U1⁢[i]. Note that the transition monoid of U1⁢[i] is isomorphic to a submonoid of U1 from Example 1. For a trace t, U1⁢[i]⁢(t), the global state reached by U1⁢[i] when run on t, is 2 iff there exists an i-event in t with label in Σi2.

A degenerate U1⁢[i] automaton is a U1⁢[i] automaton for which Σi2=∅. As state 2 is not reachable from the initial state 1, we can safely assume that Si={1}. Observe that the transition monoid of a degenerate U1⁢[i] is the trivial monoid.

Example 18.

An asynchronous Γ-transducer over Σ whose underlying automaton is U1⁢[i] from Example 17, is denoted by U1⁢[i]^. More precisely, U1⁢[i]^=(U1⁢[i],{μa}). Recall that in U1⁢[i], Si={1,2} and Sj={1} for j≠i. Further, for each a∈Σ, μa:Sa→Γ. These output functions {μa} can be viewed as follows.

  1. 1.

    For each a such that i∈𝗅𝗈𝖼⁢(a), we identify Sa with Si. Thus, μa:Si→Γ.

  2. 2.

    For each a such that i∉𝗅𝗈𝖼⁢(a), Sa is a singleton. As a result, μa is a constant function and can be simply thought of as an element of Γ.

Note that, U1⁢[i]^ always uses 1 as the initial global state and it has an associated Γ-labelling function U1⁢[i]^:T⁢R⁢(Σ~)→T⁢R⁢(Σ×Γ~).

A degenerate U1⁢[i]^ Γ-transducer has a degenerate U1⁢[i] as its underlying automaton and has effectively only one global state. As a result, its output function can be simply specified as a output function μ:Σ→Γ.

Now we introduce the local cascade product of asynchronous transducers [4, 3] which will play an important role in later sections.

Definition 19.

Let A^=({Si},{δa},sin,{μa}) be a Γ-transducer over Σ and B^=({Qi},{δ(a,γ)},qin,{ν(a,γ)}) be Π-transducer over Σ×Γ. We define the local cascade product of A^ and B^ to be the Π-transducer A^∘ℓB^=({Si×Qi},{∇a},(sin,qin),{τa}) over Σ where ∇a((sa,qa))=(δa⁢(sa),δ(a,μa⁢(sa))⁢(qa)) and τa:Sa×Qa→Π is defined by τa⁢((sa,qa))=ν(a,μa⁢(sa))⁢(qa).

In the sequential case, that is, when |𝒫|=1, the local cascade product coincides with the well-known operation of cascade product of sequential letter-to-letter transducers.

The following lemma is easily verified. See [3] for more details.

Lemma 20.

The Π-labelling function computed by A^∘ℓB^ is the composition of the Γ-labelling function computed by A^ and the Π-labelling function computed by B^: for every t∈T⁢R⁢(Σ~),

(A^∘ℓB^)⁢(t)=B^⁢(A^⁢(t))

Although we have defined the local cascade product of transducers, it is equally easy to define the local cascade product of asynchronous automata. We refer to [3] for precise details of this construction and its connection with the wreath product operation and the resulting local cascade product principle.

4.3 Proof of Theorem 2 [𝟐→𝟑]

In this section, we provide a proof of 2→3 of Theorem 2. In view of Lemma 15, it suffices to show that languages expressed by 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] sentences are accepted by local cascade product of U1⁢[i] automata. This is precisely the content of Theorem 22.

Let φ be a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] event formula. For each trace t∈T⁢R⁢(Σ~) and event e in t, we let μφ⁢(e)∈{⊤,⊥} be the truth value of φ at e, and we let θφ be the {⊤,⊥}-labelling function given by θφ⁢(t)=(E,≤,(λ,μφ)), for each t=(E,≤,λ)∈T⁢R⁢(Σ~).

Lemma 21.

Let φ be a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] event formula and let θφ be the corresponding {⊤,⊥}-labelling function. Then we can construct a local cascade product A^φ of U1⁢[i]^ transducers which computes θφ.

Proof.

The construction of A^φ proceeds by structural induction on φ. We first consider the base case with φ=a. Fix some process i∈𝗅𝗈𝖼⁢(a). We let A^φ be the degenerate {⊤,⊥}-transducer U1⁢[i]^ over Σ whose output function is μ:Σ→{⊤,⊥} where μ⁢(b)=⊤ if b=a and μ⁢(b)=⊥ otherwise. Clearly, the {⊤,⊥}-labelling function computed by A^φ coincides with θφ.

Now we consider the inductive case where φ=𝖸𝖯iφ′. By induction, we have {⊤,⊥}-transducer A^φ′ which computes θφ′. Note that the output alphabet of A^φ′ is Π=Σ×{⊤,⊥} with the distribution Πi=Σi×{⊤,⊥}.

We construct A^φ as a local cascade product A^φ′∘ℓB^, where B^ is a {⊤,⊥}-transducer U1⁢[i]^ over Π defined below, so that A^φ computes θφ. In view of Lemma 20, A^φ⁢(t)=B^⁢(A^φ′⁢(t)). By induction on φ′, A^φ′=θφ′. Thus, the requirement that A^φ computes θφ simply translates to the requirement that B^⁢(θφ′⁢(t))=θφ⁢(t).

Let t=(E,≤,λ) be a trace over Σ and t′=θφ′⁢(t)=(E,≤,(λ,μ′)). Further, let t′′=θφ⁢(t)=(E,≤,(λ,μ)). As φ=𝖸𝖯iφ′, for an event e∈E, μ⁢(e)=⊤ iff e is an i-event and there is an i-event f in the strict past of e such that μ′⁢(f)=⊤.

We are now ready to construct B^ as a U1⁢[i]^ transducer over Π so as B^⁢(t′)=t′′. The local component for process i in B^=U1⁢[i]^ is as depicted in the figure below.

More precisely, for B^ over Π, with Si={1,2}, the only non-self-loop transitions (from local state 1 to local state 2) are on letters of the form (a,⊤) with a∈Σi. The output functions are as follows. For a∈Σi, μ(a,∗)⁢(1)=⊥, μ(a,∗)⁢(2)=⊤ and for a∉Σi, μ(a,∗)=⊥.

Clearly, B^ outputs ⊥ on events in which process i does not participate. Further, it outputs ⊤ on an i-event only after reaching state 2 which ensures that there is an i-event in the strict past where the input label (the truth value of φ′) carries the value ⊤. It is easy to see from here that, for every t∈T⁢R⁢(Σ~), B^⁢(θφ′⁢(t))=θφ⁢(t). This in turn implies that A^φ=A^φ′∘ℓB^ correctly computes θφ.

We now consider the case where φ=φ1∨φ2. By induction, we have a transducer A^φ1 (A^φ2) which computes θφ1 (respectively θφ2). We consider the natural direct product A^=A^φ1×A^φ2 which is a ({⊤,⊥}×{⊤,⊥})-transducer which simultaneously computes the truth values of φ1 as well as φ2. We can easily see that the direct product is a special case of the cascade product. We can simply define A^φ=A^∘ℓB^ where B^ is a degenerate {⊤,⊥}-transducer U1⁢[i]^ (for any process i) over Σ×({⊤,⊥}×{⊤,⊥}) whose output function μ is as follows: μ⁢((a,b1,b2))=b1∨b2. It is easy to see that A^ computes θφ.

The remaining case where φ=¬φ′ can be similarly handled by a local cascade product of A^φ′ with a degenerate U1⁢[i]^ transducer. ◀

Theorem 22.

Let Φ be a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] sentence. There exists an asynchronous automaton AΦ which is a cascade product of U1⁢[i] automata and it accepts exactly the trace language defined by Φ. In other words, AΦ accepts LΦ={t∈T⁢R⁢(Σ~)∣t⊧Φ}.

Proof.

A basic 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] trace formula Φ is of the form 𝖤jφ, where φ is a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] event formula. For a trace t, we have that t⊧𝖤jφ iff there exists a j-event e in the trace such that t,e⊧φ. From Lemma 21 we have a {⊤,⊥}-transducer A^φ which is a local cascade product of U1⁢[i]^ transducers such that A^φ=θφ. Let t=(E,≤,λ) be any trace over Σ. It is clear that t⊧𝖤jφ iff some j-event in the output trace t′=A^φ⁢(t) is labelled by ⊤. Therefore the desired property of AΦ is that it should accept the trace t iff t′ has a ⊤-labelled j-event. To achieve this, we simply take the cascade product of the {⊤,⊥}-transducer A^φ with an asynchronous automaton U1⁢[j] over Σ×{⊤,⊥}. Beginning in the initial global state 1, the non-trivial component of U1⁢[j] automaton owned by process j waits at local state 1 for the label ⊤ to occur on j-events and transits to local state 2 after seeing the label ⊤ and stays there thereafter. This U1⁢[j] automaton is depicted in the figure below.

In order to accept LΦ, in the automaton AΦ=A^φ∘ℓU1⁢[j], we define a global state of AΦ to be accepting if its component for the last (in the cascade product) U1⁢[j] global state is 2. As A^φ is a local cascade product of U1⁢[i]^ transducers and the underlying automaton for each U1⁢[i]^ is simply a U1⁢[i] automaton, it is not difficult to see that AΦ is in fact a local cascade product of U1⁢[i] automata.

This takes care of basic primitive languages defined by sentences of the form 𝖤iφ. As a general sentence Φ is a boolean combination of sentences of the form 𝖤iφ, LΦ is also a boolean combination of basic primitive languages. The result for general Φ follows as boolean combinations can be handled by direct product construction which can be easily implemented by the local cascade product construction. ◀

4.4 Proof of Theorem 2 [𝟑→𝟏]

In this subsection, we provide a proof of 3→1 of Theorem 2 in the form of Theorem 24.

Lemma 23.

Let A be an asynchronous automaton over Σ which is a local cascade product of U1⁢[i] automata. Then the transition monoid of A is ℛ-trivial.

Proof.

Let A=({Si},{δa},si⁢n) be a local cascade product of U1⁢[i] automata. We show that there is a partial order ≤ on the global state set S=∏i∈𝒫Si such that, for every (s,a)∈S×Σ, Δa⁢(s)≤s (recall that, Δa:S→S is the natural global transition function induced by the joint transition function δa:Sa→Sa). It is known [6] and easy to see that the existence of such a partial order implies that the transition monoid of A is ℛ-trivial.

We show the existence of the required partial order by induction on the number of constituent U1⁢[i] automata in A. In the base case, A itself is a U1⁢[i]. As the global state set of U1⁢[i] is {1,2} (see Example 17), by setting ≤ to be the total order with 2<1, we get the desired property.

To complete the inductive step, we assume the existence of a partial order ⪯ on the global state set S of A. We now use it to construct the required partial order ≤ on the global state set of A∘ℓU1⁢[i]. Note that the global state set of A∘ℓU1⁢[i] is simply S×{1,2}. We define ≤ as follows: for s,s′∈S and k,k′∈{1,2}, (s′,k′)≤(s,k) iff s′⪯s, and k′≤k. In other words, ≤ is simply the direct product of ⪯ on S and the total order on {1,2} with 2<1. Let a∈Σ, then the (global) deterministic transition on a of A∘ℓU1⁢[i] takes the state (s,k) to the state (s′,k′)=(Δa⁢(s),Δ(a,sa)⁢(k)). It is clear from this description that (s′,k′)≤(s,k). This shows that ≤ on S×{1,2} has the desired property and we are done. ◀

Theorem 24.

Let L⊆T⁢R⁢(Σ~) be accepted by an asynchronous automaton A which is a local cascade product of U1⁢[i] automata. Then L is ℛ-trivial.

Proof.

We consider the transition monoid M⁢(A) associated with A. Recall that it is the finite monoid consisting of {Δt:t∈T⁢R⁢(Σ~)} where Δt is the global transition function on the global state set induced by the trace t. By the previous lemma, this monoid is ℛ-trivial. Due to the local nature of the transitions of A, if a and b are independent then Δa and Δb commute. As a result, we have a well defined morphism h:T⁢R⁢(Σ~)→M⁢(A) which sends t to Δt. Suppose that L is accepted by A with si⁢n as the initial global state and F as a subset of global accepting states of A. Then L is recognized by the trace morphism h via the set {Δt∈M⁢(A)∣Δt⁢(si⁢n)∈F}. Hence L is ℛ-trivial. ◀

5 Results on related fragments

In this section we briefly present other results which are of the same form as Theorem 2 but for trace languages which are ℒ-trivial or recognized by monoids from the class DA. First we shall define the necessary terminology and then subsequently state the results.

𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] is the fragment of temporal logic over traces which contains both the strict future (𝖷𝖥) and the strict past (𝖸𝖯) modality. We give below the syntax for 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] and only explain the semantics of the new modality 𝖷𝖥.

Φ ::=𝖤φ∣Φ1∨Φ2∣¬Φ
φ ::=a∣φ1∨φ2∣¬φ∣𝖷𝖥φ∣𝖸𝖯φ

For a trace t=(E,≤,λ) and an event e∈E, we have t,e⊧𝖷𝖥φ if there exists an event f in t with e<f and t,f⊧φ. Observe that 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] is the past fragment of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯]. We can similarly define 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] is as the future fragment of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] which has access to only 𝖷𝖥 modality.

For a trace t=(E,≤,λ), the reverse trace tr=(E,≤′,λ) is defined to be the trace where, for e,f∈E, e≤′f iff f≤e. For a trace language L⊆T⁢R⁢(Σ~), the reverse language Lr is defined as Lr={tr∣t∈L}.

For a monoid M, Mr denotes the opposite monoid with multiplication ∘r defined as m∘rn:=n∘m for all m,n∈Mr. It is easy to see that L is recognized by M iff Lr is recognized by Mr. Further, it it easy to deduce that M is ℒ-trivial iff Mr is ℛ-trivial. It follows that L is ℒ-trivial iff Lr is ℛ-trivial.

It is also easy to verify that L is 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] definable iff Lr is 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] definable. Given a sentence Φ in 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] defining L, we can obtain a 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯] sentence Φr which defines Lr by simply replacing all occurrences of 𝖷𝖥 operators in Φ by 𝖸𝖯, and vice versa. In view of the above discussion, it follows from Theorem 2 that a trace language L is ℒ-trivial iff it is definable in 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥].

In order to obtain a translation of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥], or more generally, 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] event formulas and sentences into cascade products of asynchronous devices, as in Lemma 21 and Theorem 22 for 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯], we work with localized modalities 𝖷𝖥i and 𝖸𝖯i and use non-deterministic asynchronous automata/transducers.

We can define the localized logic 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂,𝖸𝖯𝗂] by using the process indexed modalities 𝖷𝖥i, 𝖸𝖯i and 𝖤i instead of 𝖷𝖥, 𝖸𝖯 and 𝖤 as in Section 4.1. The semantics of 𝖷𝖥i modality is as follows: for a trace t=(E,≤,λ) and e∈E, t,e⊧𝖷𝖥iφ iff e is an i-event and there exists an i-event f with e<f such that t,f⊧φ. It can be shown that 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂,𝖸𝖯𝗂] has the same expressive power as 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯]. Observe that 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯𝗂] is a fragment of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂,𝖸𝖯𝗂]. One can similarly define the fragment 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂] of 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂,𝖸𝖯𝗂] which has the same expressive power as 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥].

Now we turn our attention to local cascade product of non-deterministic asynchronous automata and transducers. For the purpose of this work, it suffices to work with deterministic and reverse deterministic versions and their cascade products.

We begin with the key example of the reverse deterministic asynchronous automata U1r⁢[i]. In U1r⁢[i], the local state set of process i has two states, that is, Si={1,2} while all other processes have a singleton state set Sj={1} for j≠i. For a letter a∉Σi, the processes participating in a have a deterministic transition, namely, a self-loop.

Figure 2: U1r⁢[i] automata: on the left is the local automaton for process i, on the right is the local single state automaton for every other process j≠i.

If a∈Σi=Σi1⊎Σi2, we can identify a joint a-state with the local state of process i. With this identification, process i has non-deterministic transitions as shown in Figure 2. For instance, assume a∈Σi2. Then there is no transition on a at state 1. Further, at state 2, on a, the next state can be either state 1 or state 2. Note that these local transitions are obtained by simply reversing the local transitions in the deterministic U1⁢[i] automata.

We always use the global state 1 as the only final/accepting state. It is important to observe that, for a trace t, U1r⁢[i] admits a unique accepting run ρt (which ends in global state 1). If t has no i-event with label in Σi2, then ρt must begin in global state 1 and stays there until the end. However, if t has an i-event with label in Σi2, then ρt must begin in the global state 2 and process i component changes its local state from 2 to 1 on the last occurrence of an i-event with label in Σi2. After this crucial event, process i stays at local state 1 as all subsequent “future” i-events are labelled by letters in Σi1. This unambiguity property of U1r⁢[i] is crucial. While using U1r⁢[i] as a language acceptor, we allow a set of initial global states. Thanks to the unambiguity property, the language accepted with single initial global state 1 is the complement of the language accepted with single initial global state 2.

Now we introduce the reverse deterministic asynchronous Γ-transducers U1r⁢[i]^. The underlying automaton of U1r⁢[i]^ is U1r⁢[i] and the output function provides a label from Γ on each local transition of U1r⁢[i]. In U1r⁢[i]^, we allow any initial global state but insist that 1 is the only accepting state. We also associate with U1r⁢[i]^ a Γ-labelling function U1r⁢[i]^:T⁢R⁢(Σ~)→T⁢R⁢(Σ×Γ~) as follows: let t=(E,≤,λ) and ρt be the unique accepting run of the underlying U1r⁢[i] on t. We define U1r⁢[i]^⁢(t) to be the trace t′=(E,≤,(λ,μ)) where, for e∈E, μ⁢(e) is the label from Γ on the transition used to “read” e on the unique run ρt.

Let Γ={⊤,⊥}. We now construct an instance of a Γ-transducer U1r⁢[i]^ over Σ×Γ. This transducer, called U𝖷𝖥i^ below, implements the localized modality 𝖷𝖥i.

Figure 3: U𝖷𝖥i^ transducer which implements 𝖷𝖥i modality.

Consider a 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥𝗂,𝖸𝖯𝗂] formula φ=𝖷𝖥iφ′. We have the Γ-relabelling functions θφ′ and θφ which keep track of truth values of φ′ and φ respectively. Let t=(E,≤,λ) be a trace over Σ and θφ′⁢(t)=(E,≤,(λ,μ′)) and θφ⁢(t)=(E,≤,(λ,μ)) be traces over Σ×Γ. For any event e of t, μ′⁢(e)=⊤ iff t,e⊧φ′ and μ⁢(e)=⊤ iff t,e⊧φ. Fix an event e∈E. By semantics of 𝖷𝖥i, μ⁢(e)=⊤ iff e is an i-event and there exists a strict future i-event f (that is, e<f) such that μ′⁢(f)=⊤. For the Γ-transducer U𝖷𝖥i^ over Σ×Γ, depicted in Figure 3, it is easy to verify that, for every trace t over Σ, U𝖷𝖥i^((θφ′(t))=θφ(t).

In view of the above discussion, it is not surprising that the following theorem holds. We skip the technical details.

Theorem 25.

Let L⊆T⁢R⁢(Σ~). Then the following are equivalent.

  1. 1.

    L can be expressed by a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯].

  2. 2.

    L can be accepted by a cascade product of U1⁢[i] and U1r⁢[i] automata.

Even over words, the above result appears to be new. Further, we note that it has been shown in [17] (also see [11], [10]) that, over trace languages, 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥,𝖸𝖯] definability coincides with recognizability by monoids from the class DA.

The following theorem is a dual of our main theorem.

Theorem 26.

Let L⊆T⁢R⁢(Σ~). The following are equivalent.

  1. 1.

    L is a ℒ-trivial trace language.

  2. 2.

    L can be expressed by a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥].

  3. 3.

    L can be accepted by a cascade product of U1r⁢[i] automata.

Recall that a trace language is 𝒥-trivial iff it is ℛ-trivial as well as ℒ-trivial. This observation leads to the following result.

Theorem 27.

Let L⊆T⁢R⁢(Σ~). The following are equivalent.

  1. 1.

    L is a 𝒥-trivial trace language.

  2. 2.

    L can be expressed by a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖷𝖥] as well as a sentence in 𝖫𝗈𝖼𝖳𝖫⁢[𝖸𝖯].

  3. 3.

    L can be accepted by a cascade product of U1r⁢[i] automata as well as another cascade product of U1⁢[i] automata.

References

  • [1] Bharat Adsul, Paul Gastin, Shantanu Kulkarni, and Pascal Weil. An expressively complete local past propositional dynamic logic over Mazurkiewicz traces and its applications. In Proceedings of the 39th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS’24, New York, NY, USA, 2024. Association for Computing Machinery. doi:10.1145/3661814.3662110.
  • [2] Bharat Adsul, Paul Gastin, Saptarshi Sarkar, and Pascal Weil. Wreath/cascade products and related decomposition results for the concurrent setting of Mazurkiewicz traces. In Igor Konnov and Laura Kovács, editors, 31st International Conference on Concurrency Theory, CONCUR 2020, September 1-4, 2020, Vienna, Austria (Virtual Conference), volume 171 of LIPIcs, pages 19:1–19:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPICS.CONCUR.2020.19.
  • [3] Bharat Adsul, Paul Gastin, Saptarshi Sarkar, and Pascal Weil. Asynchronous wreath product and cascade decompositions for concurrent behaviours. Log. Methods Comput. Sci., 18, 2022. doi:10.46298/LMCS-18(2:22)2022.
  • [4] Bharat Adsul and Milind A. Sohoni. Asynchronous automata-theoretic characterization of aperiodic trace languages. In Kamal Lodaya and Meena Mahajan, editors, FSTTCS 2004: Foundations of Software Technology and Theoretical Computer Science, 24th International Conference, Chennai, India, December 16-18, 2004, Proceedings, volume 3328 of Lecture Notes in Computer Science, pages 84–96. Springer, 2004. doi:10.1007/978-3-540-30538-5_8.
  • [5] Mikołaj Bojańczyk. Languages recognised by finite semigroups, and their generalisations to objects such as trees and graphs, with an emphasis on definability in monadic second-order logic, 2020. arXiv:2008.11635.
  • [6] J.A. Brzozowski and Faith E. Fich. Languages of R-trivial monoids. Journal of Computer and System Sciences, 20(1):32–49, 1980. doi:10.1016/0022-0000(80)90003-3.
  • [7] Joëlle Cohen, Dominique Perrin, and Jean-Eric Pin. On the expressive power of temporal logic. Journal of Computer and System Sciences, 46(3):271–294, 1993. doi:10.1016/0022-0000(93)90005-H.
  • [8] Volker Diekert and Paul Gastin. Pure future local temporal logics are expressively complete for Mazurkiewicz traces. Information and Computation, 204(11):1597–1619, November 2006. doi:10.1016/J.IC.2006.07.002.
  • [9] Volker Diekert, Paul Gastin, and Manfred Kufleitner. A survey on small fragments of first-order logic over finite words. Int. J. Found. Comput. Sci., 19(3):513–548, 2008. doi:10.1142/S0129054108005802.
  • [10] Volker Diekert, Martin Horsch, and Manfred Kufleitner. On first-order fragments for Mazurkiewicz traces. Fundamenta Informaticae, 80(1-3):1–29, 2007. URL: http://content.iospress.com/articles/fundamenta-informaticae/fi80-1-3-02.
  • [11] Volker Diekert and Manfred Kufleitner. On first-order fragments for words and Mazurkiewicz traces: a survey. In Proceedings of the 11th international conference on Developments in language theory, pages 1–19, 2007.
  • [12] Volker Diekert and Grzegorz Rozenberg, editors. The Book of Traces. World Scientific, 1995. doi:10.1142/2563.
  • [13] Werner Ebinger and Anca Muscholl. Logical definability on infinite traces. Theor. Comput. Sci., 154(1):67–84, 1996. doi:10.1016/0304-3975(95)00130-1.
  • [14] Kousha Etessami and Thomas Wilke. An until hierarchy and other applications of an Ehrenfeucht-Fraïsse game for temporal logic. Information and Computation, 160(1):88–108, 2000. doi:10.1006/inco.1999.2846.
  • [15] Giovanna Guaiana, Antonio Restivo, and Sergio Salemi. On aperiodic trace languages. In Christian Choffrut and Matthias Jantzen, editors, STACS 91, 8th Annual Symposium on Theoretical Aspects of Computer Science, Hamburg, Germany, February 14-16, 1991, Proceedings, volume 480 of Lecture Notes in Computer Science, pages 76–88. Springer, 1991. doi:10.1007/BFB0020789.
  • [16] Johan Anthony Willem Kamp. Tense Logic and the Theory of Linear Order. University of California, Los Angeles, CA, USA, 1968.
  • [17] Manfred Kufleitner. Polynomials, fragments of temporal logic and the variety DA over traces. Theoretical Computer Science, 376:89–100, 2007. Special issue DLT 2006. doi:10.1016/J.TCS.2007.01.014.
  • [18] Robert McNaughton and Seymour A Papert. Counter-Free Automata (MIT research monograph no. 65). The MIT Press, 1971.
  • [19] Madhavan Mukund and Milind A. Sohoni. Keeping track of the latest gossip in a distributed system. Distributed Comput., 10(3):137–148, 1997. doi:10.1007/s004460050031.
  • [20] M.P. Schützenberger. On finite monoids having only trivial subgroups. Information and Control, 8(2):190–194, 1965. doi:10.1016/S0019-9958(65)90108-7.
  • [21] Howard Straubing. Finite automata, formal logic, and circuit complexity. Birkhaüser Verlag, Basel, Switzerland, 1994.
  • [22] Wolfgang Thomas. On logical definability of trace languages. In V. Diekert, editor, Proceedings of a workshop of the ESPRIT Basic Research Action No 3166: Algebraic and Syntactic Methods in Computer Science (ASMICS), Kochel am See, Bavaria, FRG (1989), Report TUM-I9002, Technical University of Munich, pages 172–182, 1990.
  • [23] Wieslaw Zielonka. Notes on finite asynchronous automata. RAIRO Theor. Informatics Appl., 21(2):99–135, 1987. doi:10.1051/ita/1987210200991.