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,nM, p,qM:n=mp and m=nq 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 pq. 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, FO2 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,eE, e is said to be an immediate successor of e, denoted by ee, if e is below e (e<e) and there is no event f strictly between e and e (fE, e<f<e).

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

  1. 1.

    for e,eE, if ee, then λ(e) and λ(e) are dependent;

  2. 2.

    for e,eE, if λ(e) and λ(e) are dependent, then they are ordered (ee or ee).

For a trace t=(E,,λ) we sometimes slightly abuse notation to say event et which we take to mean that event eE. The set of process i-events in t is defined as Ei={eEλ(e)Σi}. Note that Ei is totally ordered by . For an event et, 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={ftfe} to be the set of events in t below e. Similarly e={ftf<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 TR(Σ~). We define the trace concatenation operation on TR(Σ~) as follows. Let t1=(E1,1,λ1),t2=(E2,2,λ2)TR(Σ~) with E1E2=. We define t1t2 or simply t1t2 to be the trace (E1E2,,λ)TR(Σ~) where:

  1. 1.

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

  2. 2.

    For all eE1E2, λ(e)=λ1(e) if eE1 and λ2(e) if eE2.

A trace t is said to be a prefix of trace t if there exists t′′TR(Σ~) such that t=tt′′. It is easy to see that, for et, 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 mM, m1M=1Mm=m. The set TR(Σ~), 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:MN such that: h(1M)=1N and for all m1,m2M, h(m1m2)=h(m1)h(m2).

A subset LTR(Σ~) is called a trace language over Σ~. We call a morphism from the trace monoid TR(Σ~) to any other monoid M as a trace morphism. A trace language LTR(Σ~) is recognizable if there exists a trace morphism h from TR(Σ~) to a finite monoid M such that L=mPh1(m) for some PM. 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,m2M. The Green’s preorder relations are defined as follows:

  1. 1.

    m1Rm2 (read as m1 is R-below m2) if there exists mM such that m1=m2m.

  2. 2.

    m1Lm2 if there exists mM such that m1=mm2.

  3. 3.

    m1Jm2 if there exist u,vM such that m1=um2v

  4. 4.

    m1Hm2 if m1Rm2 and m1Lm2

These preorders naturally give rise to the associated equivalence relations ,,𝒥,. We say that m1m2 (read as m1 is -equivalent to m2) if m1Rm2 and m2Rm1. A monoid M is -trivial if m1,m2M, m1m2 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 LTR(Σ~) 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, 11=1, 01=10=00=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 LTR(Σ~). 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.

12 is shown in Theorem 14, 23 is shown in Theorem 22, 31 is shown in Theorem 24.

The result we wish to prove in this section is the 12 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 TR(Σ~) 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 eE, 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 aAa 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 tTR(Σ~) be a trace and et 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φk1i). Consider the 𝖫𝗈𝖼𝖳𝖫[𝖸𝖯] sentence Φm,n=𝖤(Σjφn1j¬φnjφmi). Clearly Φm,n has the property that trace t satisfies Φm,n if and only if the mth process i-event is strictly below the nth 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:TR(Σ~)M to a fixed finite -trivial monoid M.

Let t=(E,,λ) be a trace and eE 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={eEh(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 XtEi. Assume XtEi={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(ek1)<Rh(ek1)Rh(e1)<Rh(e1)R1M.

Therefore k<|M| which concludes the proof.

A configuration of t is a subset CE of events which is downward closed: C=C. Clearly, for any event eE, 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=Ct where t is the trace induced by the set EC of events of t which do not belong to C.

A configuration C of t is critical if for every maximal event eC, 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 eC such that h(C)<Rh(C{e}) but h(e)=h(e). We have that h(C)=h(e)h(Ce). Substituting h(e) by h(e), we get h(C)=h(e)h(Ce)=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 xy=min(2,x+y). In other words, 0 is the neutral element, 2 is absorbent, and 11=2. We have 2<R1<R0. Consider the (truncated) length trace morphism h:TR(Σ~)M defined by h(x)=1 for all xΣ. Finally, let t=abc=(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 eE, 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 CXt. 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=abc 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:TR(Σ~)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 a1a2anΣ is identified with the structure ({e1,e2,,en},,λ) with λ(ei)=ai and e1e2en. 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 tTR(Σ~) and for all linearizations w𝖫𝗂𝗇(t), we have h(w)=h(t).

For every monoid element mM we define Σm={aΣmh(a)=m} as the set of letters stabilizing m. The complement ΣΣm={aΣmh(a)m} also denoted Σm¯ is the set of letters which cause an -descent for m. This means that for every aΣm¯ mh(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=a1a2ak𝖫𝗂𝗇(𝗍𝗒𝗉𝖾(t)). We have w=(Xt,,λ) with Xt={e1,e2,,ek}, e1e2ek 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,,ek1},,λ) and v=a1ak1𝖫𝗂𝗇(𝗍𝗒𝗉𝖾(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,tTR(Σ~) 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 TR(Σ~) 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)tTR(Σ~)}. 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 tTR(Σ~). Note that, by Lemma 9, if σ=(X,,λ) is a type then π(σ)=h(w) for all w𝖫𝗂𝗇(σ).

Let t=(E,,λ) be a trace and eE 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)=(Xe,,λ)=(Xte,,λ). 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)=mh(a)m. We deduce that Xe{e}Xf: 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,,λ)TR(Σ~) 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 k0 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)TR(Σ~) be a trace with τ=𝗍𝗒𝗉𝖾(s)=(Xs,s,λs). For an element xXs, we let τx=(τx,s,λs) be the restriction of the labelled poset τ to the critical events strictly below x (τx={yXsy<sx}). It is easy to see that τx=𝗍𝗒𝗉𝖾(s,x)=𝗍𝗒𝗉𝖾(sx) where sx={eEse<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 xXs 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 φτxax. Finally, if ZXs, we let τZ=(τZ,s,λs). Then, τZ=𝗍𝗒𝗉𝖾(sZ) is a type and we let mZ=π(τZ)=h(sZ). We define

φτ =φ1φ2φorder φ1 =𝖸𝖧(φcritφstab)
φ2 =xXs𝖸𝖯φ(τ,x) φcrit =xXsφ(τ,x)
φorder =x,yXsx<sy𝖸𝖯(φ(τ,y)𝖸𝖯φ(τ,x))x,yXsxsy¬𝖸𝖯(φ(τ,y)𝖸𝖯φ(τ,x))
φstab =Z=τZXsΣmZxZ𝖸𝖯φ(τ,x)xXsZ¬𝖸𝖯φ(τ,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 φcrit) or is labelled with a stabilizing letter for the type Z arising out of the “events” x in τ

  • φorder: 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 xXs, there exists an event exte, 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={exxXs}Xte.

Now, using the fact that t,eφorder and the unicity of the events ex, we deduce that for all x,yXs, we have xsy if and only if extey. We also know that for all xXs, we have λs(x)=ax=λt(ex). Therefore, τ(Y,t,λt).

In order to obtain τ𝗍𝗒𝗉𝖾(t,e)=(Xte,t,λt) as desired, it remains to prove that Y=Xte. Towards a contradiction, assume that this is not the case and consider a minimal event fXteY. Since t,eφ1, we have t,fφcritφstab. If t,fφcrit then t,fφ(τ,x) for some xXs and by the unicity constraint f=exY, a contradiction. Hence, t,fφstab and there is a downward closed set Z=τZXs such that λt(f)ΣmZ and tfY={exxZ}. By minimality of f, we get tfXte=tfY={exxZ}. We deduce that 𝗍𝗒𝗉𝖾(t,f)=({exxZ},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)=(Xte,t,λt) we get a one-one correspondence xXsexXte such that for all x,yXs we have xsy if and only if extey and λt(ex)=λs(x). We deduce that 𝗍𝗒𝗉𝖾(t,ex)τx and λt(ex)=ax for all xXs. Therefore, t,exφ(τ,x) for all xXs and t,eφ2.

Next, it is easy to check that t,eφorder using the unicity property (Lemma 11) and the fact that x<sy if and only if ex<tey for all x,yXs.

Let fte be an event in the strict past of e. Either fXte is a critical event and f=ex for some xXs. In this case, we get t,fφ(τ,x) and t,fφcrit. Or fteXte is a non-critical event. Let Z={xXsex<f}. Then, Z=τZ is downward closed and using the unicity property we deduce that t,fxZ𝖸𝖯φ(τ,x)xXsZ¬𝖸𝖯φ(τ,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φstab. We have shown that t,eφ1.

Lemma 13.

For every element mM 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 LTR(Σ~) be recognized by the morphism h:TR(Σ~)M. Then there is a sentence ΦL of 𝖫𝗈𝖼𝖳𝖫[𝖸𝖯] which defines L: for all traces tTR(Σ~), tΦLtL.

Proof.

As L is recognized by h, there is a subset PM such that L=h1(P). For each monoid element mM, we define below a sentence Φm of 𝖫𝗈𝖼𝖳𝖫[𝖸𝖯] which defines the trace language h1(m): for all traces t we have tΦmh(t)=m. The sentence defining L is ΦL=mPΦm.

Let #Σ be a new letter. We extend the distributed alphabet Σ~ by making # an action shared by all processes: Σ~#={Σi{#}}i𝒫. For each trace tTR(Σ~), we consider the augmented trace t¯=t#TR(Σ~#) 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#φmh(e#)=mh(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 23 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 31 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 1k|𝒫| and for each 1jk, there is a process ij𝒫 such that ej1,ej are both ij-events. It is easy to deduce from here that

𝖸𝖯φ=i1,i2,,ik𝒫1k|𝒫|𝖸𝖯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:SaSa 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, sinS is a designated initial global state.

Let sS be a global state. We can write s as (sa,sa) where sa is the projection of s onto 𝗅𝗈𝖼(a) and sa is the projection onto 𝒫𝗅𝗈𝖼(a). For any letter aΣ, we can extend the joint transition function δa:SaSa to a global transition function Δa:SS on global states as follows: Δa((sa,sa))=(δa(sa),sa). For a trace tTR(Σ~), we let Δε be the identity function on S, and define Δt:SS as the composition Δt=ΔaΔt when t=ta. 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 {ΔttTR(Σ~)}. 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 FS to be the set of accepting global states then we say L(A,F)={tA(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). TR(Σ~) and TR(Σ×Γ~) are the set of traces over the original and extended distributed alphabets. A function θ:TR(Σ~)TR(Σ×Γ~) is called a Γ-labelling function if, for every t=(E,,λ)TR(Σ~), θ(t)=(E,,(λ,μ))TR(Σ×Γ~). 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^:TR(Σ~)TR(Σ×Γ~) to also denote the Γ-labelling function computed by the transducer A^. For t=(E,,λ)TR(Σ~), we define A^(t)=(E,,(λ,μ))TR(Σ×Γ~) such that, for every eE 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 ji 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 ji. 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]^:TR(Σ~)TR(Σ×Γ~).

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 tTR(Σ~),

(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 23 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 tTR(Σ~) 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,,λ)TR(Σ~).

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 eE, μ(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 tTR(Σ~), 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))=b1b2. 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Φ={tTR(Σ~)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 31 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},sin) 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:SS is the natural global transition function induced by the joint transition function δa:SaSa). 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 AU1[i]. Note that the global state set of AU1[i] is simply S×{1,2}. We define as follows: for s,sS and k,k{1,2}, (s,k)(s,k) iff ss, and kk. 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 AU1[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 LTR(Σ~) 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:tTR(Σ~)} 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:TR(Σ~)M(A) which sends t to Δt. Suppose that L is accepted by A with sin 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 {ΔtM(A)Δt(sin)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 eE, 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,fE, ef iff fe. For a trace language LTR(Σ~), the reverse language Lr is defined as Lr={trtL}.

For a monoid M, Mr denotes the opposite monoid with multiplication r defined as mrn:=nm for all m,nMr. 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 eE, 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 ji. 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 ji.

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]^:TR(Σ~)TR(Σ×Γ~) 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 eE, μ(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 eE. 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 LTR(Σ~). 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 LTR(Σ~). 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 LTR(Σ~). 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.