�� �� �� �� �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �  � �  � �  � �  � �  � �  � �  � �  � � � �� � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � �  � �  � �  � �  � �  � �  � �  � � � � � � � � � � � � � � � � � � � �  � �  � �  � �  � �  � �  � �  � �  � � � � � � � �  � �  � �  � �  � �

UNIVERSITÄT STUTTGART FAKULTÄT INFORMATIK

Proceedings ASMICS Workshop Infinite Traces

Tübingen, January 23 - 25, 1992

Volker Diekert, Werner Ebinger

(Editors)

Bericht 4/92

Preface

The workshop Infinite Traces was held at Tübingen, Hotel Hospiz, from January 23 to 25, 1992. The idea to this workshop was born at the general ASMICS meeting at Menaggio. It is the second ASMICS workshop on Free Parially Commutative Monoids, the first one was held at Kochel 1989. Whereas the Kochel workshop gave an representative overview over the different activities in the research field, the subject of the new workshop was restricted to the special theme of infinite traces with the aim of gathering only few experts.

The workshop was attended by 8 participants from six different European universities and in addition by three guests from the University of Stuttgart. The scientific programme started with lectures on Thursday, January 23 and ended at noon of Saturday January 25, 1992. In the afternoon of Saturday there was an excursion to the famous Hohenzollern castle at Hechingen about 30 km South of Tübingen.

The good working athmosphere at Hotel Hospiz and the active collaboration made this meeting to a successful event. We thank all participants for their contribution. We would like to express our gratitude to ASMICS and the Institut für Informatik of the University of Stuttgart for financial and other support. In paricular, we thank Heike Photien for local help. Last, but not least we thank Frau Elke Veihelmann from Hotel Hospiz for the warm and kind reception.

Stuttgart May 5, 1992

Volker Diekert Werner Ebinger

Programme Workshop Infinite Traces

Tübingen, January 23-25, 1992, Hotel Hospiz

Thursday January 23
9.30 – 9.40  Volker Diekert  Opening
9.45 – 10.30 Giovanni Pighizzini  Operations on asynchronous automata
11.15 – 12.15 Paul Gastin  Büchi asynchronous cellular automata
16.15 – 17.15 Mike Stannett  Convergence in trace languages
Friday  January 24
9.30 – 10.30 Hendrik Jan Hoogeboom Automata on infinite words
11.00 – 12.00 Werner Ebinger  On logical definability of

infinite trace languages

16.00 – 16.30 Mike Stannett  Transfinite traces
17.45 – 18.30 Wojciech Penczek  Temporal logic in trace systems
19.00 – 20.30 Volker Diekert (Chair)  Discussion
Saturday January 25
9.30 – 10.30 Antoine Petit  Poset properties of complex traces
10.30 – 11.00 Volker Diekert  Two extensions of existing models
11.15 – 12.45 Hendrik Jan
Hoogeboom (Chair)  Open problems session
14.00 – 17.00 Excursion

Contents

Preface 1 Programme of the workshop 2 Participants of the workshop 4 G. Pighizzini: Synthesis of nondeterministic asynchronous automata 5 P. Gastin, A. Petit: Büchi asynchronous cellular automata 29 M. Stannett: Trace Convergence over infinite alphabets I 46 M. Stannett: Trace Convergence over infinite alphabets II 72 J. Engelfriet, H. J. Hoogeboom: Automata with storage on infi-

nite words 82 W. Ebinger: On logical definability of ω-trace languages 106 M. Kwiatowska, M. Stannett: On transfinite traces 123 W. Penczek: On temporal logics on trace systems 158 P. Gastin, A. Petit: Poset properties of complex trace languages 205 V. Diekert: Two extensions of the existing trace model 218 V. Diekert, P. Gastin, A. Petit: Rational and Recognizable Com-

plex Trace Languages 225 Open problems 270

List of participants

Workshop Infinite Traces, Tbingen, January 23-25,

1992 Hotel Hospiz

Volker Diekert  Stuttgart
Werner Ebinger  Stuttgart
Hendrik Jan Hoogeboom  Leiden
Paul Gastin  Paris
Wojtek Penczek  Warsaw
Antoine Petit  Orsay
Giovanni Pighizzini  Milano
Nicoletta Sabadini  Milano
Mike Stannett  Sheffield

Guests

Siegmar Gerber  Stuttgart/Leipzig
Anca Muscholl  Stuttgart
Klaus Reinhardt^{1}  Stuttgart

1Not on the picture, since he took the photograph.

Synthesis of Nondeterministic Asynchronous Automata

Giovanni Pighizzini ^{†}

Dipartimento di Scienze dell’Informazione Università degli Studi di Milano

Abstract

In this paper we give an algorithm for building a nondeterministic asynchronous automaton recognizing the trace language

[Maz77] denoted by a given recognizable expression. Moreover, we show that the number of states of the automaton so obtained is polynomial in the length of the expression.

1 Introduction

Asynchronous Automata were introduced by W. Zielonka [Zie87] as algebraic abstactions of distributed systems. This kind of automata is very interesting since, as shown in [Zie87, CM88], they characterize the class of recognizable trace languages [BBMS81], that is the class of languages accepted by finite automata over free partially commutative monoids.

Another characterization of the class of recognizable trace languages were discovered by E. Ochmański [Och85], proving that the class of recognizable trace languages coincides with the minimal class containing finite trace languages and closed under union, product and a new operation called concurrent iteration.

In this paper we give an algorithm for building nondeterministic asynchronous automata accepting the union, the product and the concurrent iteration of trace languages accepted by given nondeterministic asynchronous automata. Our constructions are nontrivial generalizations of the corresponding constructions for finite automata (see for example [HopUll67]). The number of states of the resulting automaton is polynomial in the number of states of the given automata. The algorithm for building the asynchronous automaton accepting the concurrent iteration of the language accepted by a given asynchronous automaton is obtained using a new interesting result concerning the iteration of trace languages. More precisely, we prove that the iteration of a trace language T can be expressed as finite union of the iterations of suitable languages T_{1}, …, T_{m} such that in every language T_{i}, 1 ≤ i ≤ m, all traces have exactly the same set of letters.

†Author’s address: Dipartimento di Scienze dell’Informazione, Via Comelico 39, 20135 Milano, Italy – Email: pighizzi@imiucca.csi.unimi.it PP Supported in part by the ESPRIT Basic Research Action No. 3166: “Algebraic and Syntactic Methods in Computer Science (ASMICS)” and by MURST 40%.

2 Traces and trace languages

In this section we briefly recall the basic notions concerning trace languages.

Definition 2.1 A concurrent alphabet is a pair (A, θ), where A is a finite alphabet and θ ⊆ A × A is a symmetric and irreflexive relation, called independency relation. If (a, b) ∈ θ then we will say that a and b are independent letters; otherwise a and b are dependent. Cliques(A, θ) denotes a (fixed) family of cliques covering the complement of θ.

The free partially commutative monoid (fpcm, for short) generated by (A, θ) is defined as the initial object in the category of monoids generated by A and satisfying, besides the usual monoid axioms, the set of “commutativity laws” {ab = ba | aθb}. A trace is an element of M(A, θ). A trace language is a subset of M(A, θ).

It is well–known that M(A, θ) is isomorphic to the quotient structure A/ ≡_{θ} where ≡_{θ} is the least congruence over A^{∗} extending the set of commutativity laws. Then, a trace is an equivalence class of words. The equivalence class containing the word w ∈ A^{∗} will be denoted as [w]_{θ} or by [w] if θ is understood. A trace x is said to be a prefix (suffix) of a trace t if and only if there is a trace z such that t = xz (t = zx, respectively).

The set of symbols of a trace t ∈ M(A, θ) will be denoted by alph(t), i.e. alph(ϵ) = ∅ and alph(ta) = alph(t) ∪ {a} for t ∈ M(A, θ), a ∈ A. Moreover, alph(T) = ⋃_{t∈T} alph(t) for every T ⊆ M(A, θ). A subset α ⊆ A is said to be connected if for a, b ∈ α we can find a_{0}, a_{1}, …, a_{n} ∈ α such that a_{0} = a, a_{n} = b and (a_{i−1}, a_{i}) ∉ θ for i = 1, …, n. A trace t is connected if alph(t) is connected. A language T is connected if and only if every trace in T is connected.

A trace u is a component of a trace t if u is connected and there exists a trace v such that t = uv and alph(u) × alph(v) ⊆ θ. The set of all components of a trace t will be denoted as c(t).

We are interested in the usual regular operations (union, product and iteration, denoted, as usual, with the symbols ·, ∪ and ^{∗}, respectively), and in the operations on trace languages defined as follows:

Definition 2.2 Let T be a trace language over the fpcm M(A, θ), and α a subset of A. The decomposition of T, denoted by c(T) is the set of all components of traces in T, i.e. c(T) = ⋃_{t∈T} c(t). The concurrent iteration (coiteration, for short) of T is the language T^{co−∗} = c(T)^{∗}. The α–restriction of T is the set T_{α} = {t ∈ T | alph(t) = α}. Finally, the restricted iteration of T is the language T^{⊕} defined as follows:

T^{⊕} = \{ \begin{matrix}T^{+} & if T = T_{α} for some connected set α ⊆ A \\ ∅ & otherwise, \end{matrix}

where, as usual, T^{+} denotes the language T · T^{∗}.

The class Reg(A, θ) of regular trace languages over (A, θ) [Maz77] is defined as the smallest class containing the languages ∅, {[ϵ]}, {[a]}, for all a ∈ A, and closed with respect to the regular operations. On the other hand, the class Rec(A, θ) of recognizable trace languages over (A, θ) can be defined in a standard way using the notion of M(A, θ)– automata [BBMS81]. It is known that if the independency relation θ is not empty then the class Rec(A, θ) is properly included in the class Reg(A, θ).

The following characterization of the class Rec(A, θ) were obtained by Ochmański [Och85]:

Theorem 2.1 For every concurrent alphabet (A, θ), the class Rec(A, θ) of recognizable trace languages over (A, θ) is the smallest class of trace languages containing the languages ∅, {[ϵ]}, {[a]}, for all a ∈ A, and closed under union, product and coiteration.

As a consequence of the last theorem, every recognizable trace language can be denoted by a recognizable expression, i.e. an expression involving operators representing the operations of union, product and coiteration of trace languages.

Given a set S, the family of subsets of S will be denoted as P(S).

Lemma 2.1 Let P ⊆ P(A) be a family of subsets of A and T ⊆ M(A, θ) a trace language. If T is recognizable then also the language ⋃_{α∈P} T_{α} is recognizable.

As a consequence of this lemma, for every recognizable language T the following sets are recognizable: the α–restriction of T (T_{α}, for α ⊆ A), the set of all connected traces in T, the set of all nonconnected traces in T, the set {t ∈ T | γ ⊆ alph(t) ⊆ α} = ⋃_{γ⊆β⊆α} T_{β}, for γ ⊆ α ⊆ A.

3 A result on the iteration of trace languages

In this section we state our main result concerning the iteration of trace languages.

Given a set α ⊆ A, α ≠ ∅, a composition of α is an ordered partition of α, i.e. a sequence p_{1}, …, p_{s}, s ≥ 1, of nonempty subsets of α whose union is equal to α and such that p_{i} ∩ p_{j} = ∅ for i ≠ j. The set of all compositions of α will be denoted by Π(α).

Theorem 3.1 Given a language T ⊆ M(A, θ) and a set α ⊆ A, consider the language Z ⊆ M(A, θ) so defined:

Z = \{ \begin{matrix}⋃_{(p_{1},...,p_{s})∈Π(α)} XY_{p_{1}}XY_{p_{2}} … Y_{p_{s}}X, & if α ≠ ∅; \\ \{[ϵ]\}, & otherwise, \end{matrix}

where X = ⋃_{β⊂α}(T^{∗})_{β}, and Y_{p_{j}} = ⋃_{p_{j}⊆β⊆α} T_{β}, for j = 1, …, s. Then, (T^{∗})_{α} = Z^{+} and alph(t) = α for every trace t ∈ Z,i.e. Z = Z_{α}.

Proof. Before of proving the Theorem we remark that in the definition of X the union operation is extended to every subset β strictly included in α. For α = ∅ the proof is trivial. Then, we suppose α ≠ ∅.

The inclusion Z^{+} ⊆ (T^{∗})_{α} can be easily verified. The converse inclusion, is a consequence of the following lemma:

Lemma 3.1 For every trace u ∈ (T^{∗})_{α}, either u ∈ Z or there are traces u′, u′′ such that u = u′u′′, u′ ∈ Z, |u′′| < |u| and u′′ ∈ (T^{∗})_{α}.

Proof. Since u ∈ (T^{∗})_{α} and α ≠ ∅, we can find traces u_{1}, …, u_{m} ∈ T, m ≥ 1 such that u = u_{1} … u_{m}. Since alph(u) = α, there is an index k, 1 ≤ k ≤ m, such that alph(u_{1} … u_{k}) = α and alph(u_{1} … u_{k−1}) ≠ α. We consider the sequence α_{1}, …, α_{k} of subsets of α such that α_{i} = alph(u_{i}) − ⋃_{j=1}^{i−1} α_{j}, for j = 1, …, k. Clearly, ⋃_{j=1}^{k} α_{j} = α and α_{i} ∩ α_{j} = ∅, for i ≠ j. From the sequence α_{1}, …, α_{k}, we extract the subsequence α_{j_{1}}, …, α_{j_{s}} by eliminating the empty subsets (observe that j_{s} = k). This sequence is a composition of α and α_{j_{r}} ⊆ alph(u_{j_{r}}) ⊆ α, for r = 1, …, s. Then, u_{j_{r}} ∈ Y_{α_{jr}}. By construction, the set β = alph(u_{j_{r−1}+1} … u_{j_{r}−1}) is strictly included in α, for r = 1, …, s, j_{0} = 0. On the other hand, u_{j_{r−1}+1} … u_{j_{r}−1} ∈ T^{∗}. So:

u_{j_{r−1}+1} … u_{j_{r}−1} ∈ (T^{∗})_{β} ⊆ ⋃_{β⊂α}(T^{∗})_{β} = X.

This permits us to conclude that u_{1} … u_{k} ∈ XY_{α_{j_{1}}} X … XY_{α_{js}} and, observing that [ϵ] ∈ X, we have: u_{1} … u_{k} ∈ XY_{α_{j_{1}}} X … XY_{α_{js}} X ⊆ Z. Now, we set u′ = u_{1} … u_{k} and u′′ = u_{k+1} … u_{m}. Observe that |u′| > 1 Clearly, alph(u′′) ⊆ α. If alph(u′′) = α then u′′ ∈ (T^{∗})_{α} and |u′′| < |u| and the statement is proved. On the other hand, if alph(u′′) ≠ α then u′′ ∈ (T^{∗})_{alph(u′′)} ⊆ X. Recalling that u_{1} … u_{k} ∈ XY_{α_{j_{1}}} X … XY_{α_{js}}, it turns out that u = u′u′′ ∈ (XY_{α_{j_{1}}} X … XY_{α_{js}})X ⊆ Z. Then u ∈ Z. This concludes the proof of the lemma.

Now, using the previous lemma, it is possible to show by induction on the length of traces t ∈ M(A, θ) that t ∈ (T^{∗})_{α} implies t ∈ Z^{+}. Then (T^{∗})_{α} ⊆ Z^{+}.

Corollary 3.1 For every trace language T ⊆ M(A, θ) there are languages T_{1}, …, T_{m}, m ≥ 0, such that T^{∗} = ⋃_{i=1}^{m}(T_{i})^{∗} and for every i (i = 1, …, m) there is a subset α of A for which T_{i} = (T_{i})_{α}.

4 Asynchronous Automata

In this section we briefly recall the definition and some properties of Asynchronous Automata.

Definition 4.1 A nondeterministic asynchronous automaton (NAA) with n processes, over the concurrent alphabet (A, θ), is a tuple M = (P_{1}, …, P_{n}, {δ_{a}}_{a∈A}, I, F ), where:

• for i = 1, …, n, P_{i} = (A_{i}, S_{i}) is the ith process, where S_{i} is its set of local states and A_{i} is its local alphabet, such that {A_{1}, …, A_{n}} = Cliques(A, θ);

• let P roc = {1, …, n}, and, for a ∈ A, let be Dom(a) = {i ∈ P roc | a ∈ A_{i}} the set of (indices of) processes that execute a; then δ_{a} : ∏_{i∈Dom(a)} S_{i} → P(∏_{i∈Dom(a)} S_{i}) is the local transition function associated to the letter a;

• let S = ∏_{i∈P roc} S_{i} be the set of global states; then I ⊆ S is the set of the initial states and F ⊆ S is the set of final states.

A global state will be denoted by a boldface letter, as s, while its ith component as s_{i}; given a global state s ∈ S and a set of (indices of) processes α = {i_{1}, …, i_{k}} ⊆ P roc, we will denote by s_{|α} the vector whose components correspond to local states in α, i.e. s_{|α} = (s_{i_{1}}, …, s_{i_{k}}).

The global transition function Δ : S × M(A, θ) → P(S) of the automaton M is defined on the ground of local transition functions as follows. For every s, u ∈ S, a ∈ A, we have: u ∈ Δ(s, a) if and only if u_{|Dom(a)} ∈ δ_{a}(s_{|Dom(a)}) and u_{|\overline{Dom(a)}} = s_{|\overline{Dom(a)}}. The extension to traces can be obtained in a standard way.

The language accepted by the automaton M is defined as the set:

T (M) = {t ∈ M(A, θ) | Δ(I, t) ∩ F ≠ ∅}.

If #I = 1 and # (δ_{a}(s_{i_{1}}, …, s_{i_{k}})) ≤ 1 for every (s_{i_{1}}, …, s_{i_{k}}) ∈ ∏_{i∈Dom(a)} S_{i},

a ∈ A, the automaton M is said to be a deterministic asynchronous automaton (DAA).

It is immediate to verify that to every asynchronous automaton can be associated a finite state automaton recognizing the same trace language. Moreover, given a finite automaton over the the fpcm M(A, θ) it is possible to construct a DAA with the same concurrent alphabet, accepting the same language. This result, not at all obvious, were obtained by W. Zielonka.

Theorem 4.1 [Zie87] The class of languages accepted by deterministic asynchronous automata over (A, θ) coincides with the class Rec(A, θ) of trace languages recognized by M(A, θ)–automata.

Another proof of Theorem 4.1 can be found in [CM88].

From this point on, we consider a fixed concurrent alphabet (A, θ) with a fixed clique cover Cliques(A, θ) = {A_{1}, …, A_{n}}, of the dependency relation. For all notations concerning NAA the reader is referred to this section. When we deal with different NAA M, M′ and M′′, we always suppose that A_{i} = A′_{i} = A′′_{i} and S′_{i} ∩ S′′_{i} = ∅ for i ∈ P roc.

4.1 Asynchronous automata with ϵ–moves

Here, we consider an extension of NAA useful in our algorithm. In the model we will consider every process can change its internal state, independently from the states of other processes and from the next input symbol, using an internal transition called ϵ–move. The ϵ–moves are represented extending every local alphabet with a new symbol. More precisely, we consider the concurrent alphabet (Â, θ̂) such that Â = A ∪ {e_{1}, …, e_{n}}, where {e_{1}, …, e_{n}} ∩ A = ∅, and

θ̂ = θ ∪ {(e_{i}, e_{j}) | i ≠ j} ∪ {(a, e_{i}), (e_{i}, a) | a ∈ A − A_{i}}.

Then Cliques(Â, θ̂) = {Â_{1}, …, Â_{n}}, where Â_{i} = A_{i} ∪ {e_{i}}, i = 1, …, n.

To every trace t̂ ∈ M(Â, θ̂) we associate the trace ψ(t̂) ∈ M(A, θ) obtained erasing from t̂ all letters not belonging to A. Given a language T̂ ⊆ M(Â, θ̂) we denote by ψ(T̂) the set ⋃_{t̂∈_{T}} ψ(t̂).

The following theorem states an important relationship between NAA over M(Â, θ̂) and NAA over M(A, θ).

Theorem 4.2 Let T̂ ⊆ M(Â, θ̂) be the language accepted by a NAA M̂. Then, there exists a NAA over M(A, θ) accepting the language ψ(T̂).

Proof (outline). The automaton M is defined as follows: S_{i} = Ŝ_{i}, i = 1, …, n; I = {s ∈ S | ∃w ∈ M(Â, θ̂) s.t. alph(w) ⊆ {e_{1}, …, e_{n}} and s ∈ Δ̂(Î, w)}; F = F̂; for a ∈ A with Dom(a) = {i_{1}, …, i_{k}}, s ∈ ∏_{i∈Dom(a)} S_{i}:

δ′_{a}(s) = {u ∈ ∏_{i∈Dom(a)} S_{i} | ∃s′, u′ ∈ Ŝ s.t. s′_{|Dom(a)} = s, u′_{|Dom(a)} = u,

∃w ∈ M(Â, θ̂) s.t. alph(w) ⊆ {e_{i_{1}}, …, e_{i_{k}}}, and u′ ∈ Δ̂(s′, aw)}.

It is possible to prove that for t ∈ M(A, θ) it holds: Δ(I, t) = ⋃_{t̂∈ψ^{−1}(t)} Δ̂(I, t̂).

5 Synthesis of Asynchronous Automata

In this section we give an algorithm for building nondeterministic asynchronous automata from recognizable expressions.

First, we observe that asynchronous automata accepting the languages ∅, {[ϵ]} and {[a]}, a ∈ A, can be trivially constructed.

5.1 Union

The construction of a NAA M accepting the union of the languages accepted by two given NAA M′ and M′′ is trivial. Then, we give it without any comment.

We define M as follows: S_{i} = S′_{i} ∪ S′′_{i}, i = 1, …, n; I = I′ ∪ I′′; F = F′ ∪ F′′; for a ∈ A and s ∈ ∏_{i∈Dom(a)} S_{i}:

δ_{a}(s) = \{ \begin{matrix}δ′_{a}(s) & if s ∈ ∏_{i∈Dom(a)} S′_{i} \\ δ′′_{a}(s) & if s ∈ ∏_{i∈Dom(a)} S′′_{i} \\ ∅ & otherwise. \end{matrix}

It is easy to verify that for every global state s ∈ I and for every trace t ∈ M(A, θ) Δ(s, t) is equal to Δ′(s, t) (Δ′′(s, t)) if s ∈ I′ (s ∈ I′′, respectively). So, M can simulate the computations of M′ and M′′ and it recognizes the language T (M′) ∪ T (M′′).

5.2 Product

Given two NAA M′ and M′′, for every s ∈ S′, let M′_{s} be the NAA M′_{s} = (P′_{1}, …, P′_{n}, {δ′_{a}}_{a∈A}, I′, {s}) and for every s ∈ S′′ let _{s}M′′ be the NAA _{s}M′′ = (P′′_{1}, …, P′′_{n}, {δ′′_{a}}_{a∈A}, {s}, F′′). Then T (M′) · T (M′′) = ∪_{(s′,s′′)∈F′×I′′}T (M′_{s′} · T (_{s′′}M′′). This observation permit us of considering in this section only automata M′ and M′′ such that #F′ = 1 and #I′′ = 1. We will denote by F′ = (F′_{1}, …, F′_{n}) the only final state of M′ and by I′′ = (I′′_{1}, …, I′′_{n}) the only initial state of M′′.

We define the following automaton M with ϵ–moves.

• S_{i} = S′_{i} ∪ S′′_{i}, i = 1, …, n;

• I = I′;

• F = F′′;

• for a ∈ A with Dom(a) = {i_{1}, …, i_{k}}, s_{i_{j}} ∈ S_{i_{j}}, j = 1, …, k:

δ_{a}(s_{i_{1}}, …, s_{i_{k}}) = \{ \begin{matrix}δ′_{a}(s_{i_{1}}, …, s_{i_{k}}) & if s_{i_{j}} ∈ S′_{i_{j}}, 1 ≤ j ≤ k, \\ δ′′_{a}(s_{i_{1}}, …, s_{i_{k}}) & if s_{i_{j}} ∈ S′′_{i_{j}}, 1 ≤ j ≤ k, \\ ∅ & otherwise; \end{matrix}

• for i = 1, …, n, s_{i} ∈ S_{i}:

δ_{e_{i}}(s_{i}) = \{ \begin{matrix}\{I′′_{i}\} & if s_{i} = F′_{i}, \\ ∅ & otherwise. \end{matrix}

Now, we prove that T (M) = T (M′){[e_{1} … e_{n}]}T (M′′). First, we get the following immediate remarks. Remarks

(a) For every trace t ∈ M(A, θ) (i.e., T does not contain any symbol corresponding to an ϵ–move) and for every s ∈ S′: Δ(s, t) = Δ′(s, t);

(b) for every trace t ∈ M(A, θ) and for every s ∈ S′′: Δ(s, t) = Δ′′(s, t);

(c) Δ(F′, [e_{1} … e_{n}]) = I′′;

(d) for every t ∈ T (M) every process P_{i} on input t executes exactly one ϵ-move, i.e. |t|_{e_{i}} = 1.

Now, we can prove the following theorem.

Theorem 5.1 T (M) = T (M′){e_{1} … e_{n}}T (M′′)

Proof. The inclusion of T (M′){[e_{1} … e_{n}]}T (M′′) in T (M) is an immediate consequence of previous remarks. In order to prove the converse inclusion, we consider a trace t ∈ T (M). From Remark (d), we can find traces u_{0}, …, u_{n} ∈ M(A, θ) and a permutation (i_{1}, …, i_{n}) of (1, …, n) such that t = u_{0}e_{i_{1}}u_{1}e_{i_{2}} … e_{i_{n}}u_{n}. Let be 1 ≤ k ≤ n and a ∈ alph(u_{k}). Then u_{k} = vaw for suitable traces v, w ∈ M(A, θ) and t = u_{0} … e_{i_{k}}vawe_{i_{k+1}} … u_{n}. Since M accepts t, there are global states s′, s′′ ∈ S such that:

s′ ∈ Δ(I′, u_{0} … e_{i_{k}}v),

s′′ ∈ Δ(s′, a) and

Δ(s′′, we_{i_{k+1}} … u_{n}) ∩ F ≠ ∅. More precisely, we can observe that both local states s′_{i_{j}}, s′′_{i_{j}} belong to S′_{i_{j}}, for j > k, while both s′_{i_{j}}, s′′_{i_{j}} belong to S′′_{i_{j}} for j ≤ k. Then, from the definition of δ_{a} and from Δ(s′, a) ≠ ∅ it follows that either Dom(a) ⊆ {i_{k+1}, …, i_{n}} or Dom(a) ⊆ {i_{1}, …, i_{k}}. So, we can decompose u_{k} as product of two independent traces u′_{k} and u′′_{k}, s.t. Dom(u′_{k}) ⊆ {i_{k+1}, …, i_{n}} and Dom(u′′_{k}) ⊆ {i_{1}, …, i_{k}}. Moreover Dom(u′′_{k})∩Dom(u′_{j}) = ∅ for j > k. Then, we can rewrite t as u′_{0} … u′_{n}[e_{1} … e_{n}]u′′_{0} … u′′_{n}. Finally, let s ∈ I′, q ∈ F′′ be the states corresponding to the start and to the end of such an accepting computation. More precisely:

s′ ∈ Δ(s, u_{0} … e_{i_{k}}v) and q ∈ Δ(s′′, we_{i_{k+1}} … u_{n}). It is easy to observe that:

F′ ∈ Δ′(s, u′_{0} … u′_{n}) and q ∈ Δ′′(I′′, u′′_{0} … u′′_{n}). Then u′_{0} … u′_{n} ∈ T (M′) and u′′_{0} … u′′_{n} ∈ T (M′′).

Finally, applying the construction given in the proof of Theorem 4.2, we can obtain a NAA accepting the language T (M′)T (M′′).

5.3 Concurrent iteration

In this section, we will show how it is possible to construct a NAA recognizing the coiteration of the language recognized by a given NAA. To achieve this goal, we will prove that the coiteration T^{co−∗} of a trace language T can be expressed by means of the operations of union, product, decomposition, α–restriction and restricted iteration, applied starting from T, and we will give algorithms for building asynchronous automata accepting the decomposition, the α–restriction and the restricted iteration of the language accepted by a given NAA.

First, we recall that T^{co−∗} = (c(T))^{∗} = ⋃_{α⊆A}((c(T))^{∗})_{α} and we prove that every language (T^{co−∗})_{α} = ((c(T))^{∗})_{α} can be expressed inductively from T and (T^{co−∗})_{β}, where β is strictly included in α, using the above mentioned operations.

For α = ∅, we have (T^{co−∗})_{∅} = {[ϵ]}. Suppose now that α ≠ ∅. If α is nonconnected, we have (T^{co−∗})_{α} = ((c(T))^{+})_{α_{1}} ·. . .·((c(T))^{+})_{α_{k}}, where the sets α_{1}, …, α_{k} are the connected components of α; then ((c(T))^{+})_{α_{j}} = (T^{co−∗})_{α_{j}}, with α_{j} ⊂ α, j = 1, …, k.

On the other hand, if α is connected, then by Theorem 3.1 we have: (T^{co−∗})_{α} = Z^{+}, where Z = ⋃_{(p_{1},...,p_{s})∈Π(α)} XY_{p_{1}}XY_{p_{2}} … Y_{p_{s}}X, X = ⋃_{β⊂α}((c(T))^{∗})_{β} = ⋃_{β⊂α}(T^{co−∗})_{β}, and, for j = 1, …, s, Y_{p_{j}} = ⋃_{p_{j}⊆β⊆α} c(T)_{β}. Moreover, alph(t) = α, for every trace t ∈ Z. Then Z^{+} = Z^{⊕}. This implies that (T^{co−∗})_{α} = Z^{⊕}.

As a consequence of this discussion, it is easy to obtain the following new characterization of the class of recognizable trace languages:

Theorem 5.2 The class Rec(A, θ) of recognizable trace languages over (A, θ) is the smallest class containing the languages ∅, {[ϵ]}, and {[a]} (for a ∈ A) and closed with respect to the operations of union, product, decomposition, restricted iteration and α–restriction.

Now, we have to give the constructions of NAA accepting the α– restriction, the decomposition and the restricted iteration of the trace language accepted by a given NAA.

5.3.1 Restriction

Here, we briefly describe how it is possible to build a NAA accepting the restriction of the language accepted by a given NAA. The idea is essentialy that of keeping in every local state the alphabet of the trace executed so far. More precisely, we consider the set of local states S′_{i} = S_{i}× P(A_{i}), i ∈ P roc, the set of initial global states I′ = {((s_{1}, ∅), …, (s_{n}, ∅)) | s ∈ I}, and the local transition function δ_{a}, a ∈ A, such that:

δ′_{a}((s_{i_{1}}, α_{i_{1}}), …, (s_{i_{k}}, α_{i_{k}})) =
{((u_{i_{1}}, α_{i_{1}} ∪ {a}), …, (u_{i_{k}}, α_{i_{k}} ∪ {a})) |
(u_{i_{1}}, …, u_{i_{k}}) ∈ δ_{a}(s_{i_{1}}, …, s_{i_{k}})},

for s_{i_{j}} ∈ S_{i_{j}}, α_{i_{j}} ⊆ A_{i_{j}}, j = 1, …, k, where {i_{1}, …, i_{k}} = Dom(a). It is not difficult to verify that for every trace t ∈ M(A, θ), it holds:

Δ′(I′, t) = {((s_{1}, alph(t) ∩ A_{1}), …, (s_{n}, alph(t) ∩ A_{n})) | s ∈ Δ(I, t)}.

We now define two NAAs M_{k} = (P′_{1}, …, P′_{n}, {δ′_{a}}, I′, F_{k}), k = 1, 2. M_{1} is obtained choosing as set of final states the set:

F_{1} = {((s_{1}, α_{1}), …, (s_{n}, α_{n}))|(s_{1}, …, s_{n}) ∈ F }.

Of course, the language accepted by M_{1} coincides with the language accepted by M, i.e., T (M_{1}) = T (M). Fixed a set α ⊆ A, in order to recognize the α–restriction of T (M) we have to accept all traces of T (M) whose alphabet is exactly α. This goal can be achieved setting

F_{2} = {((s_{1}, α_{1}), …, (s_{n}, α_{n}))|(s_{1}, …, s_{n}) ∈ F and ⋃_{i=1}^{n} α_{i} = α}.

It is clear that T (M_{2}) = (T (M))_{α}.

5.3.2 Decomposition

The technique above explained for the construction of a NAA accepting the restriction of the language accepted by a given NAA, can be extended in order to obtain a NAA for the decomposition.

Given a NAA M, we define the sets of local states S′_{i} = S_{i} × P(A_{i}) × S_{i}, i = 1, …, n, the set of initial global states I′′ = {((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})) | r ∈ I}, and the local transition function, for a ∈ A, with Dom(a) = {i_{1}, …, i_{k}}, s_{i_{j}}, r_{i_{j}} ∈ S_{i_{j}}, α_{i_{j}} ⊆ A_{i_{j}}, j = 1, …, k:

δ′′_{a}((s_{i_{1}}, α_{i_{1}}, r_{i_{1}}), …, (s_{i_{k}}, α_{i_{k}}, r_{i_{k}})) =
{((u_{i_{1}}, α_{1} ∪ {a}, r_{i_{1}}), …, (u_{i_{k}}, α_{k} ∪ {a}, r_{i_{k}})) |
(u_{i_{1}}, …, u_{i_{k}}) ∈ δ_{a}(s_{i_{1}}, …, s_{i_{k}})}.

Then, for every t ∈ M(A, θ) and for every r ∈ S:

Δ′′(((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})), t) = = {((s_{1}, alph(t) ∩ A_{1}, r_{1}), …, (s_{n}, alph(t) ∩ A_{n}, r_{n})) | s ∈ Δ(r, t)}.

Let now t be a trace in the language T (M) = T (M_{1}) and t′ a connected component of t, i.e., t = t′t′′, alph(t′) is connected and alph(t′) × alph(t′′) ⊆ θ, for some t′′ ∈ M(A, θ). Then t′ ∈ c(T (M)). Since t is accepted by M, we can find global states u ∈ F, r ∈ I such that u ∈ Δ(r, t). So:

((u_{1}, alph(t) ∩ A_{1}, r_{1}), …, (u_{n}, alph(t) ∩ A_{n}, r_{n})) ∈
Δ′′(((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})), t).

Let be Γ = Dom(t′) and, for i = 1, …, n:

(s_{i}, α_{i}, r_{i}) = \{ \begin{matrix}(u_{i}, alph(t) ∩ A_{i}, r_{i}) & if i ∈ Γ, \\ (r_{i}, ∅, r_{i}) & otherwise. \end{matrix}

It is possible to verify that:

((s_{1}, α_{1}, r_{1}), …, (s_{n}, α_{n}, r_{n})) ∈ Δ′(((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})), t′),

the set ⋃_{i=1}^{n} α_{i} = alph(t′) is connected and α_{i} × (alph(t) ∩ A_{j}) ⊆ θ, for i ∈ Γ, j ∈ P roc − Γ. Moreover, it turns out that alph(t′′′) = alph(t′), t′′′t′′ ∈ T (M) and t′′′ ∈ c(T (M)), for every trace t′′′ such that ((s_{1}, α_{1}, r_{1}), …, (s_{n}, α_{n}, r_{n})) ∈ Δ′′(((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})), t′′′).

From this discussion, we can conclude that the NAA M′′ = (P′′_{1}, …, P′′_{n}, {δ′′_{a}}, I′′, F′′), where F′′ is the set:

F′′ = {((s_{1}, α_{1}, r_{1}), …, (s_{n}, α_{n}, r_{n})) |
r ∈ I, ∃ u ∈ F, t ∈ M(A, θ) s.t. u ∈ Δ(r, t),
∃Γ ⊆ P roc s.t. ∀i ∈ Γ s_{i} = u_{i}, α_{i} = alph(t) ∩ A_{i},
∀i ∉ Γ s_{i} = r_{i}, α_{i} = ∅,
the set ⋃_{i=1}^{n} α_{i} is connected and
α_{i} × (alph(t) ∩ A_{j}) ⊆ θ, for i ∈ Γ, j ∈ P roc − Γ},

recognizes the decomposition of T (M).

Remark The condition ∃t ∈ M(A, θ) s.t. u ∈ Δ(r, t) is useful to assure that only connected components of traces of T (M) are accepted. In fact, it can happen that there is none trace t such that u ∈ Δ(r, t), i.e. u is not reachable from r, but ((s_{1}, α_{1}, r_{1}), …, (s_{n}, α_{n}, r_{n})) ∈ Δ′(((r_{1}, ∅, r_{1}), …, (r_{n}, ∅, r_{n})), t′) for some t′ ∈ M(A, θ) − c(T (M)), and the global state ((s_{1}, α_{1}, r_{1}), …, (s_{n}, α_{n}, r_{n})) satisfies the other requirements of the definition of F′′.

5.3.3 Restricted iteration

First, we observe that given a NAA M accepting a trace language T ⊆ M(A, θ) we can decide if T = T_{α} for some connected set α ⊆ A, by constructing a finite state automaton M accepting T and verifying if M is equivalent to some automaton M_{α} accepting the language T_{α} for a connected α ⊆ A.

Since the asynchronous automaton recognizing the empty language can be trivially constructed, from this point on we will consider the problem of building an asynchronous automaton accepting T^{⊕} = T^{+}, when T = T_{α} for some connected alphabet α ⊆ A.

Let M be a NAA accepting a trace language T, such that T = T_{α}, for some connected set α ⊆ A. There is none loss of generality assuming that the following conditions hold:

1. α = A;

2. there exists a map ϕ : ⋃_{i=1}^{n} S_{i} → P(A) such that if Δ(I, t) = s then ϕ(s_{i}) = alph(t)∩A_{i}, for i = 1, …, n, t ∈ M(A, θ) (this means that the automaton M records the letters of traces. Observe that if s_{i} is a compontent of some final state p, then ϕ(s_{i}) = A_{i}).

Suppose in fact that α ⊂ A. From the asynchronous automaton M it is possible to obtain an automaton M̃ by removing all the processes P_{i} such that A_{i} ∩ α = ∅ and all transitions involving letters not belonging to α. Applying the construction presented below, we will obtain an automaton M̃′ over the concurrent alphabet (α, θ∩(α×α)). This automaton can be easily extended to the concurrent alphabet (A, θ), by introducing dummy processes and null transition functions. We observe that for the automaton M_{1} defined in Section 5.3.1, the second condition holds.

For sake of simplicity, first we suppose that #I = #F = 1. Then, we will denote by I = (I_{1}, …, I_{n}) and by F = (F_{1}, …, F_{n}) the only initial and the only final state of M, respectively.

In the classical construction of the finite automaton N′ recognizing the iteration of the language recognized by a given finite automaton N (see e.g. [HopUll67]), an empty transition from the final state to the initial state is added to N. In our case, we want to construct an automaton M′ recognizing all traces of the form t_{1}[e_{1} … e_{n}]t_{2}[e_{1} … e_{n}] … [e_{1} … e_{n}]t_{m} such that m > 0 and t_{i} ∈ T (M), i = 1, …, m. However, as shown in the following example, the immediate generalization to asynchronous automata of the strategy used for finite automata does not work.

Example Let (A, θ) be the concurrent alphabet with:

A = {a, b, c, d}, θ = {(a, c), (c, a), (a, d), (d, a), (b, d), (d, b)},

and Cliques(A, θ) = {A_{1}, A_{2}, A_{3}}, where A_{1} = {a, b}, A_{2} = {b, c} and A_{3} = {c, d}. Let M be the asynchronous automaton represented in Fig. 1. It is not difficult to see that M accepts the set T (M) = {[acbd]}.

[figure: I_{1}; r_{1}; F_{1}; I_{2}; r_{2}; F_{2}; I_{3}; r_{3}; F_{3}; a; a; b; c; d]

Figure 1: automaton M

Moreover, M satisfies the hypothesis stated above (that is α = A and there exists the map ϕ). Now, if we add, for every i ∈ P roc, a transition from the component F_{i} of the final state to the component I_{i} of the initial state, the resulting automaton can recognize a set that properly includes (T (M))^{+}. The automaton obtained applying this procedure in our specific case, is represented in Figure 2. Such an automaton accepts, for example, the trace [acbade_{2}e_{3}cbd]. Observe that Dom(b) = {1, 2}, but before the last occurrence of b, the process P_{2} executed one ϵ–move, while none ϵ–move was execute by P_{1}.

[figure: I_{1}; r_{1}; F_{1}; I_{2}; r_{2}; F_{2}; I_{3}; r_{3}; F_{3}; a; a; b; c; d; e_{1}; e_{3}; e_{2}]

Figure 2: automaton constructed introducing an ϵ–move from every component of the final state to the corresponding component of the initial state

We will show that, in order to avoid the problems arising in previous example, we have to circularly rearrange two isomorphic copies of the given NAA M.

Formally, we define M′ in the following way:

• S′_{i} = S_{i} × {0, 1}, i = 1, …, n;

• I′ = {((I_{1}, 0), …, (I_{n}, 0))};

• for a ∈ A with Dom(a) = {i_{1}, …, i_{k}}, s_{i_{j}} ∈ S_{i_{j}}, j = 1, …, k, b_{i_{1}}, …, b_{i_{k}} ∈ {0, 1}:

δ′_{a}((s_{i_{1}}, b_{i_{1}}), …, (s_{i_{k}}, b_{i_{k}})) = = {((u_{i_{1}}, b), …, (u_{i_{k}}, b)) | (u_{i_{1}}, …, u_{i_{k}}) ∈ δ_{a}(s_{i_{1}}, …, s_{i_{k}})}, if there exists b ∈ {0, 1} s.t. b_{i_{1}} = … = b_{i_{k}} = b;

δ′_{a}((s_{i_{1}}, b_{i_{1}}), …, (s_{i_{k}}, b_{i_{k}})) = ∅

otherwise.

• for i = 1, …, n, s_{i} ∈ S_{i}, b ∈ {0, 1}:

δ′_{e_{i}}(s_{i}, b) = \{ \begin{matrix}\{(I_{i}, 1 − b)\} & if s_{i} = F_{i} \\ ∅ & otherwise; \end{matrix}

• F′ = {((F_{1}, b), …, (F_{n}, b)) | b ∈ {0, 1}}.

In Figure 3, the automaton M′ obtained applying this costruction to the automaton M of Figure 1, is represented.

[figure: (I_{1},0); (r_{1},0); (F_{1},0); (I_{2},0); (r_{2},0); (F_{2},0); (I_{3},0); (r_{3},0); (F_{3},0); a; a; b; c; d; (I_{1},1); (r_{1},1); (F_{1},1); (I_{2},1); (r_{2},1); (F_{2},1); (I_{3},1); (r_{3},1); (F_{3},1); a; a; b; c; d; e_{1}; e_{2}; e_{3}; e_{1}; e_{3}; e_{2}]

Figure 3: automaton M′

To prove the correctness of the construction, we will show that the automaton M′ so defined recognizes the set of the traces of the form t_{1}[e_{1} … e_{n}]t_{2}[e_{1} … e_{n}] … [e_{1} … e_{n}]t_{m}, where m ≥ 1 and t_{i} ∈ T, i = 1, …, m.

It is not difficult to see that every trace of such a form is accepted by M′. Then, we prove the converse result.

First, we will prove the following remarks:

Remarks

(a) Between two ϵ–moves of a process P′_{i} in an accepting computation, there is at least one occurence of every letter of A_{i}.

(b) In every accepting computation of M′, before of the execution of a symbol a there is either at least one ϵ–move of every process in Dom(a) or none ϵ–move of processes in Dom(a).

(c) If some process of M′ performs an ϵ–move on an accepted trace then every process performs an ϵ–move.

Remarks (a),(b) and (c) are consequences of the following lemmas, respectively.

Lemma 5.1 If t ∈ (Â, θ̂) is accepted by M′ and t = t_{0}e_{i}t_{1}e_{i}t_{2}, for suitable traces t_{0}, t_{1}, t_{2} ∈ (Â, θ̂), then A_{i} ⊆ alph(t_{0}), A_{i} ⊆ alph(t_{1}), A_{i} ⊆ alph(t_{2}).

Proof. We prove that A_{i} ⊆ alph(t_{1}). The other proofs are very similar. First, we suppose that e_{i} ∉ alph(t_{1}). Since t ∈ T (M′), we can find suitable global states of M′ such that:

((s_{1}, b_{1}), …, (s_{n}, b_{n})) ∈ Δ′(I′, t_{0}e_{i}),

((u_{1}, b′_{1}), …, (u_{n}, b′_{n})) ∈ Δ′(((s_{1}, b_{1}), …, (s_{n}, b_{n})), t_{1}) and

Δ′(((u_{1}, b′_{1}), …, (u_{n}, b′_{n})), e_{i}t_{2}) ∩ F′ ≠ ∅. Since e_{i} ∉ alph(t_{1}), we have b_{i} = b′_{i}. Moreover (s_{i}, b_{i}) is reached after one ϵ–move of the process P_{i}. Then s_{i} = I_{i} and ϕ(s_{i}) = ∅. Since δ_{e_{i}}(u_{i}, b′_{i}) ≠ ∅, we have u_{i} = F_{i}. Then ϕ(u_{i}) = A_{i}. This implies that A_{i} ⊆ alph(t_{1}).

If e_{i} ∈ alph(t_{1}), then there are traces v_{1}, …, v_{m} such that t_{1} = v_{1}e_{i}v_{2}e_{i} … e_{i}v_{m} and e_{i} ∉ alph(v_{j}), j = 1, …, m. Using the previous argument it can be shown that A_{i} ⊆ alph(v_{j}).

Lemma 5.2 Let t ∈ M(Â, θ̂) be a trace accepted by the automaton M′, with t = ue_{i}vaw, for some u, v, w ∈ M(Â, θ̂), a ∈ A, i ∈ P roc, such that e_{i} ∉ alph(u), and let j ∈ P roc be an index such that e_{j} ∉ alph(ue_{i}v). Then {i, j} cannot be a subset of Dom(a).

Proof. Since t ∈ T (M′), there are s, s′, s′′ ∈ S, b_{1}, …, b_{n}, b′_{1}, …, b′_{n}, b′′_{1}, …, b′′_{n} ∈ {0, 1} such that:

((s_{1}, b_{1}), …, (s_{n}, b_{n})) ∈ Δ′(((I_{1}, 0), …, (I_{n}, 0)), ue_{i}),

((s′_{1}, b′_{1}), …, (s′_{n}, b′_{n})) ∈ Δ′(((s_{1}, b_{1}), …, (s_{n}, b_{n})), v),

((s′′_{1}, b′′_{1}), …, (s′′_{n}, b′′_{n})) ∈ Δ′(((s′_{1}, b′_{1}), …, (s′_{n}, b′_{n})), a),

Δ′(((s′′_{1}, b′′_{1}), …, (s′′_{n}, b′′_{n})), w) ∩ F′ ≠ ∅. If both i, j belong to Dom(a) then from Δ(((s′_{1}, b′_{1}), …, (s′_{n}, b′_{n})), a) ≠ ∅ and from e_{j} ∉ alph(uv), it turns out that b′_{i} = b′_{j} = 0. On the other hand, observing that after the ϵ–move of the process P_{i} it holds b_{i} = 1 and s_{i} = I_{i}, we can conclude that e_{i} ∈ alph(v), i.e. v = z′e_{i}z′′ for suitable traces z′ and z′′. From Lemma 5.1 we have a ∈ alph(z′) and |v| ≠ 0. Then t = ue_{i}v_{1}aw_{1}, for suitable traces v_{1}, w_{1}, with |v_{1}| < |v|. We can iterate the proof for this decomposition. So, we will find a countable sequence of traces v_{1}, v_{2}, … such that for every k |v_{k}| < |v_{k−1}| and |v_{k}| ≠ 0. This is contradictory. Then Dom(a) cannot contain both indices i and j.

Lemma 5.3 Let t ∈ M(Â, θ̂) be a trace accepted by the automaton M′. If there is an index i ∈ P roc such that e_{i} ∈ alph(t), then e_{j} ∈ alph(t), for every j ∈ P roc.

Proof. First, we prove the result for A_{i} ∩ A_{j} ≠ ∅. Since t is accepted, there exists a global state ((p_{1}, b), …, (p_{n}, b)) belonging to Δ′(I′, t)∩F′. Suppose that e_{j} ∉ alph(t). This means that the component P_{j} does not perform ϵ–moves and then b = 0. On the other hand e_{i} ∈ alph(t). Then, this ϵ–move of the component P_{i} changes the last component of the local state of P_{i} from 0 to 1. So, at least another ϵ–move must be performed by P_{i} in order to have b = 0. Then, we can decompose t as t = t_{0}e_{i}t_{1}e_{i}t_{2}. As a consequence of Lemma 5.1, for every a letter a ∈ A_{i} ∩ A_{j}, we have a ∈ alph(t_{1}). From Lemma 5.2, it turns out that {i, j} cannot be a subset of Dom(a). This is a contradiction. Then we conclude that e_{i} ∈ alph(t).

To prove the lemma in the general case, we recall that the alphabet A is connected. Then, we can find a sequence P_{i_{0}}, …, P_{i_{m}} of processes such that i_{0} = i, i_{m} = j and A_{i_{k−1}} ∩ A_{i_{k}} ≠ ∅, k = 1, …, m. The proof of the lemma follows applying the previous argument to every pair (i_{k−1}, i_{k}).

Now, we can prove the correctness of the construction stated here.

Theorem 5.3 Let M′ the NAA above defined. Then:

T (M′) = {t_{1}[e_{1} … e_{n}]t_{2} … t_{m−1}[e_{1} … e_{n}]t_{m} |
m ≥ 1 and t_{1}, …, t_{m} ∈ T (M)}.

Proof. The difficult point is to prove that every trace accepted by the automaton M′ has the form t_{1}[e_{1} … e_{n}]t_{2} … t_{m−1}[e_{1} … e_{n}]t_{m}, with m ≥ 1, t_{i} ∈ T, i = 1, …, m. First, we observe that every trace t accepted by M′ without ϵ-moves, i.e. alph(t) ⊆ A, is accepted also by the automaton M. Then, t ∈ T (M)^{+}. Suppose now that t is accepted using at least one ϵ-move. From Remark (c) it turns out that every process executes at least one ϵ-move, i.e. e_{i} ∈ alph(t) for every i ∈ P roc. So, we can decompose t as u_{0}e_{i_{1}}u_{1}e_{i_{2}} … e_{i_{n}}u_{n} where (i_{1}, …, i_{n}) is a permutation of (1, …, n) and e_{i_{j}} ∉ alph(u_{k}) for k < j. By Remark (b), either Dom(a) ⊆ {i_{1}, …, i_{k}} or Dom(a) ⊆ {i_{k+1}, …, i_{n}}, for every letter a ∈ alph(u_{k}), k = 1, …, n. Then, u_{k} = u′_{k}u′′_{k}, where Dom(u′_{k}) ⊆ {i_{k+1}, …, i_{n}} and Dom(u′′_{k}) ⊆ {i_{1}, …, i_{k}}. It is easy to verify that t = u′_{0} … u′_{n}[e_{1} … e_{n}]u′′_{0} … u′′_{n}.

Let be t′ = u′_{0} … u′_{n} and t′′ = u′′_{0} … u′′_{n}. We now briefly prove that t′ ∈ T (M) and t′′ ∈ T (M′). By definition of M′, we can find b ∈ {0, 1} such that:

((F_{1}, b), …, (F_{n}, b)) ∈ Δ′(((I_{1}, 0), …, (I_{n}, 0)), t′[e_{1} … e_{n}]t′′). More precisely, observing the definition of δ′_{e_{i}}, we obtain:

((F_{1}, 0), …, (F_{n}, 0)) ∈ Δ′(((I_{1}, 0), …, (I_{n}, 0)), t′);

((I_{1}, 1), …, (I_{n}, 1)) ∈ Δ′(((F_{1}, 0), …, (F_{n}, 0)), [e_{1} … e_{n}]);

((F_{1}, b), …, (F_{n}, b)) ∈ Δ′(((I_{1}, 1), …, (I_{n}, 1)), t′′). Since e_{i} ∉ alph(t′), i = 1, …, n, it turns out that F ∈ Δ(I, t′) and then t′ ∈ T (M). Furthermore, from these relationships, we can easily obtain:

((F_{1}, 1 − b), …, (F_{n}, 1 − b)) ∈ Δ′(((I_{1}, 0), …, (I_{n}, 0)), t′′), that implies t′′ ∈ T (M′).

At this point, iterating the previous proof on the trace t′′ it turns out that t is of the form t_{1}[e_{1} … e_{n}]t_{2} … t_{m−1}[e_{1} … e_{n}]t_{m}, with t_{j} ∈ T (M), j = 1, …, m.

Applying Theorem 4.2 to the automaton M′, we can obtain a NAA accepting the language T (M)^{+}.

Now, we briefly discuss how it is possible to generalize the previous construction when there are no restrictions on the cardinality of sets I and F.

The idea is very similar to particular case above considered. When a process P_{i} reaches a component of a final state, it can change its state, using an ϵ–move, to go in a component of an initial state.

The problem is to assure that all processes chose the same final and the same initial global state. This problem is solved in this way. At the start of the computation all processes are synchronized and an initial state s ∈ I and a final state p ∈ F are chosen. Then, the computation starts and every process simulates the corresponding process of M, keeping the pair (s, p) in its local state.

When the process P_{i} arrives to simulate the local state p_{i} of M, it can perform an empty transition choosing a new pair (s′, p′) ∈ I × F.

When a symbol a ∈ A is executed, all processes in Dom(a) are synchronized and they compare the pairs of initial and final states contained in their proper memories. If these pairs do not coincide then none transition is possible. Since all traces in the language accepted by M are connected and since the automaton M records the letters of traces, this method assures that in an accepting computation of M′ all kth empty transitions of processes correspond to the same initial and to the same final state. Formally, the automaton M is defined as follows:

• S′_{i} = S_{i} × I × F × {0, 1}, i = 1, …, n;

• I′ = {((s_{1}, s, p, 0), …, (s_{n}, s, p, 0)) | s ∈ I, p ∈ F };

• for a ∈ A with Dom(a) = {i_{1}, …, i_{k}}, s_{j} ∈ S_{i_{j}}, j = 1, …, k, q_{1}, …, q_{k} ∈ I, p_{1}, …, p_{k} ∈ F, b_{1}, …, b_{k} ∈ {0, 1}:

δ′_{a}((s_{1}, q_{1}, p_{1}, b_{1}), …, (s_{k}, q_{k}, p_{k}, b_{k})) = = {((u_{1}, q, p, b), …, (u_{k}, q, p, b)) | (u_{1}, …, u_{k}) ∈ δ_{a}(s_{1}, …, s_{k})}, if there are q ∈ I, p ∈ F, b ∈ {0, 1}, s.t. q_{1} = … = q_{k} = q, p_{1} = … = p_{k} = p, and b_{1} = … = b_{k} = b;

δ′_{a}((s_{1}, q_{1}, p_{1}, b_{1}), …, (s_{k}, q_{k}, p_{k}, b_{k})) = ∅,

otherwise.

• for i = 1, …, n, s_{i} ∈ S_{i}, q ∈ I, p ∈ F, b ∈ {0, 1}:

δ′_{e_{i}}(s_{i}, q, p, b) = \{ \begin{matrix}\{(q′_{i}, q′, p′, 1 − b) | q′ ∈ I, p′ ∈ F \} & if s_{i} = p_{i} \\ ∅ & otherwise; \end{matrix}

• F′ = {((p_{1}, q, p, b), …, (p_{n}, q, p, b)) | q ∈ I, p ∈ F, b ∈ {0, 1}}.

Previous remarks (a), (b) and (c) hold also in this case. The correctness proof given in Theorem 5.3 can be easily generalized.

6 Conclusion

We conclude the paper with some considerations on the complexity of asynchronous automata obtained applying our constructions.

It is not difficult to see that all constructions given in the paper (union, product, restriction, decomposition and restricted iteration) produce NAAs with a polynomial number of states with respect to the number of states of the NAAs given as input.

Moreover, it is possible to observe that for a fixed concurrent alphabet (A, θ) the coiteration T^{co−∗} of a trace language T can be denoted as explained in Section 5.3 using an expression involving operations of union, product, decomposition, restriction and restricted iteration, whose length is polynomial in the length of the recognizable expression given for T. Then, using the algorithms presented in this paper, for every recognizable expression it is possible to build a nondeterministic asynchronous automaton recognizing the language denoted by it and whose number of (global and local) states is polynomial in the length of the given expression.

References

[BBMS81] A. Bertoni, M. Brambilla, G. Mauri, and N. Sabadini. An application of the theory of free partially commutative monoids: asymptotic densities of trace languages. In Proc. 10th MFCS, Lecture Notes in Computer Science 118, pages 205–215, 1981.

[CM88] R. Cori and Y. Métivier. Approximation of a trace, asynchronous automata and the ordering of events in a distributed system. In Proc. 15th ICALP, Lecture Notes in Computer Science 317, pages 147–161, 1988.

[HU79] J. Hopcroft and J. Ullman. Introduction to automata theory, languages and computations. Addison–Wesley, 1979.

[Maz77] A. Mazurkiewicz. Concurrent program schemes and their interpretations. Technical Report DAIMI Rep. PB–78, Aarhus University, 1977.

[Och85] E. Ochmański. Regular behaviour of concurrent systems. EATCS Bullettin, 27:56–67, 1985.

[Zie87] W. Zielonka. Notes on finite asynchronous automata. RAIRO Inf. Theor., 21:99–135, 1987.

29 30 P. Gastin, A. Petit Büchi asynchronous cellular automata 31 32 P. Gastin, A. Petit Büchi asynchronous cellular automata 33 34 P. Gastin, A. Petit Büchi asynchronous cellular automata 35 36 P. Gastin, A. Petit Büchi asynchronous cellular automata 37 38 P. Gastin, A. Petit Büchi asynchronous cellular automata 39 40 P. Gastin, A. Petit Büchi asynchronous cellular automata 41 42 P. Gastin, A. Petit Büchi asynchronous cellular automata 43 44 P. Gastin, A. Petit Büchi asynchronous cellular automata 45 46 Trace Convergence over infinite alphabets I 47 48 M. Stannett Trace Convergence over infinite alphabets I 49 50 M. Stannett Trace Convergence over infinite alphabets I 51 52 M. Stannett Trace Convergence over infinite alphabets I 53 54 M. Stannett Trace Convergence over infinite alphabets I 55 56 M. Stannett Trace Convergence over infinite alphabets I 57 58 M. Stannett Trace Convergence over infinite alphabets I 59 60 M. Stannett Trace Convergence over infinite alphabets I 61 62 M. Stannett Trace Convergence over infinite alphabets I 63 64 M. Stannett Trace Convergence over infinite alphabets I 65 66 M. Stannett Trace Convergence over infinite alphabets I 67 68 M. Stannett Trace Convergence over infinite alphabets I 69 70 M. Stannett Trace Convergence over infinite alphabets I 71 72 Trace Convergence over infinite alphabets II 73 74 M. Stannett Trace Convergence over infinite alphabets II 75 76 M. Stannett Trace Convergence over infinite alphabets II 77 78 M. Stannett Trace Convergence over infinite alphabets II 79 80 M. Stannett Trace Convergence over infinite alphabets II 81

Automata with Storage on Infinite Words

(Extended Abstract) ^{1}

Joost Engelfriet and Hendrik Jan Hoogeboom

Leiden University, Department of Computer Science P.O. Box 9512, 2300 RA Leiden, The Netherlands

Abstract. For any storage type X, the ω-languages accepted by X-automata are investigated. Six accepting conditions (including those introduced by Landweber) are compared for X-automata. The inclusions between the corresponding six families of ω-languages are essentially the same as for finite state automata. Apart from unrestricted automata also realtime and deterministic automata are considered. The main tools for this investigation are (1) a characterization of the ω-languages accepted by X-automata in terms of (inverse) X-transductions of finite state ω-languages, and (2) the existence of topological upper bounds on some of the families of accepted ω-languages (independent of the storage type X).

Introduction

An automaton A that is meant to work on finite input words may as well be given an infinite input word u: it works on u as if u were a ‘very

1This paper was previously presented at ICALP’89 and appeared in the proceedings of the conference ([EngHoo89]). A full version of the paper is scheduled to be published in Theoretical Computer Science in the spring of 1993. large’ finite word. The essential difference is in the way that A accepts u; obviously one cannot use acceptance by final state as for finite words.

The first one to use automata to accept infinite words (with a particular acceptance criterion) was Büchi (in solving a decision problem in logic, [Büc60]). Another criterion was given by Muller ([Mul63]).A deterministic finite state automaton A accepts an infinite word u in the fashion of Muller if the set of states entered by A infinitely often during its computation on u belongs to a given family of ‘final’ state sets. This family replaces the usual set of final states. Five criteria for accepting infinite words were proposed by Landweber in [Lan69], including those introduced by Büchi and Muller, and he characterized the five corresponding families of infinitary languages accepted by deterministic finite state automata in a topological setting.

The relative power of these five acceptance criteria was subsequently compared for (nondeterministic) finite state automata ([Hos72, StaWag74]), pushdown automata ([Lin76, CohGol77, CohGol78a]), Turing machines ([WagSta77, CohGol78b]) and Petri nets ([Val83]). If one compares the results of these investigations, one notices some striking similarities (see the survey [Sta87]). It seems that the acceptance types have the same relative power independently of the storage used by the automaton involved. This observation is the main motivation for the present paper. Using a general framework we want to explain the similarities between the results obtained for the various specific types of automata (as is done for automata on finite words in [Gin75]). Our abstract model of storage is called a storage type. It describes the storage configurations together with the tests and transformations that can be applied to them. Automata equipped with a specific storage X (and a one-way input-tape) are called X-automata. We study six (rather than five) families of ω-languages that can be accepted by an X-automaton using six different acceptance criteria on the sequence of states entered by the automaton during a computation. (It should be noted that acceptance can also be defined in terms of the storage configurations rather than the states, see [Sta77], but this will give quite different results, cf. [Val83]). A possible approach to comparing the six acceptance criteria is by giving constructions on automata that show how one acceptance type can be simulated by another. In fact, as observed in [CohGol77, Val83], it is not too difficult to generalize most of the constructions given in [Hos72] for finite state automata, simply by ‘adding’ storage instructions to the transitions. Hence it is not much of a surprise that the inclusions between the six families for X-automata are similar to those formed by the families for finite state automata. Of course, this is a rather boring and time-consuming approach. Also, if one wants to study X-automata satisfying a particular property (as, e.g., being real-time or deterministic), it is necessary to check for each of the constructions whether it preserves the property under consideration (and if not, to adapt the construction). We use a more efficient way of transferring the results for finite state automata to arbitrary storages. Our main tool is a characterization of the ω-languages accepted by X-automata in terms of (infinitary) transductions applied to the ω-languages accepted by finite state automata. Since we do not use the acceptance criteria to define transductions, this single result can be used to show that the inclusions that hold between the six families of finite state ω-languages are also valid for X-automata. This of course does not indicate whether or not an inclusion is strict. We show that the topological upper-bounds on the complexity of accepted languages as given by Landweber for deterministic finite state automata can be generalized to X-automata (as already suggested in [Lan69]). This implies that for deterministic X-automata the inclusions are always strict (and the same holds for real-time automata).

In Section 3 we study both arbitrary and deterministic X-automata. First we present the above-mentioned characterization of the corresponding families of ω-languages (Theorem 3.3). From this we obtain the hierarchy for ω-languages accepted by X-automata (Theorem 3.5). For specific storage types the hierarchy can be strict or it can collapse into a single family. We give a sufficient condition for such a collapse (Theorem 3.7). Real-time automata are investigated in Section 4. The inclusions between the families of ω-languages accepted by real-time automata are very similar to those found in Section 3 (see Theorem 4.4). Here however, the inclusions are always strict. The counter-examples are obtained by establishing topological upper-bounds that are independent of the storage type. We return to deterministic automata in Section 5. Again we obtain topological upper-bounds on the accepted ω-languages. Together with our basic characterization (given in Section 3) this is used to establish a proper hierarchy similar to the hierarchy for deterministic finite state automata (Theorem 5.4). In the final section we study a storage type of ‘maximal power’. The families of ω-languages accepted by automata of this type belong to the lower levels of the topological hierarchy of Borel sets (Theorems 6.3 and 6.6). These results are similar to those obtained in [Arn83] and [Sta84] for transition systems.

1. Preliminaries

We assume the reader to be familiar with the basic notions of infinitary languages, e.g., as discussed in one of the following surveys and introductions: [Eil74, HooRoz86, Sta87, Tho88].

The symbol ⊆ (⊂) denotes set inclusion (strict set inclusion, respectively); in diagrams we will use ⇒ (and →, respectively). We use ⊓ to indicate non-disjointness of sets, i.e., U ⊓ V if U ∩ V ≠ ∅.

As usual, Σ^{∗} and Σ^{ω} denote the sets of finite words and infinite words (or ω-words) over the alphabet Σ. Their subsets are called (finitary) languages and infinitary languages (or ω-languages), respectively. The empty word is denoted by Λ. u[n] denotes the prefix of length n of a (ω- )word u (when defined), and pref (v) denotes the set of (finite) prefixes of v. For a (ω-)language K, pref (K) = ∪{pref (u)|u ∈ K}. An infinite sequence of finite words ⟨x_{i}⟩_{i∈N} such that each x_{i} is a prefix of x_{i+1} defines a unique element u of Σ^{∗} ∪ Σ^{ω} by taking the ‘least upper bound’ of the sequence, i.e., the shortest u that has each x_{i} as a prefix. u will be denoted by lub⟨x_{i}⟩_{i∈N}.

Let K ⊆ Σ^{∗} be a finitary language. The ω-power of K, denoted by K^{ω}, is {u ∈ Σ^{ω}|u = lub⟨x_{i}⟩_{i∈N}, where x_{0} ∈ K and x_{i+1} ∈ x_{i} · K for i ∈ N}, the adherence of K, denoted adh(K), is {u ∈ Σ^{ω}|pref (u) ⊆ pref (K)}, and the limit of K, denoted lim(K), is {u ∈ Σ^{ω}|pref (u) ∩ K is infinite}.

Σ^{ω} can be turned into a (compact) metric space by defining the distance function d(u, v) = 2^{− min{n|u[n]≠v[n]}} for u ≠ v. We will use G, and F to denote the family of open, respectively closed, sets in this topological space. Furthermore, G_{δ} is the family of denumerable intersections of open sets, and F_{σ} is the family of denumerable unions of closed sets. There is a close correspondence between the ω-languages in these families (that form the lower levels of the Borel hierarchy) and the language theoretical operations given above (see, e.g., [Lan69, StaWag74, BoaNiv80]).

1.1. Proposition. Let L ⊆ Σ^{ω}. Then

(1) L ∈ G if and only if L = K · Σ^{ω} for some K ⊆ Σ^{∗},

(2) L ∈ F if and only if L = adh(K) for some K ⊆ Σ^{∗}, and

(3) L ∈ G_{δ} if and only if L = lim(K) for some K ⊆ Σ^{∗}.

1.2. Proposition. 0^{∗}1 · {0, 1}^{ω} ∈ G − F, {0, 1}^{∗} · 1^{ω} ∈ F_{σ} − G_{δ}, and (0^{∗}1)^{ω} ∈ G_{δ} − F_{σ}.

2. Automata on ω-Words: Definitions

For finite words, the general notion of an automaton, using some kind of storage, was introduced in [HopUll67, Sco67, GinGre69]. The resulting AFA theory (Abstract Families of Automata) provides a useful framework for a uniform investigation of different types of automata (see [Gin75]). Here we attempt to set up a similar theory for automata on infinite words (see also [Sta77]). The particular variation of AFA theory that we use here is similar to the one in [EngVog87].

2.1. Storage and Automata

A storage type is a 5-tuple X = (C, C_{in}, P, F, μ), where C is a set of (storage) configurations, C_{in} ⊆ C is a set of initial (storage) configurations, P is a set of predicate symbols, F is a set of instruction symbols, P ∩ F = ∅, and μ is a meaning function which assigns to each p ∈ P a (total) mapping μ(p) : C → {true, false}, and to each f ∈ F a partial function μ(f) : C → C. The set of all Boolean expressions over P, using the Boolean connectives ∧, ∨ and ¬, and the constants true and false, is denoted by BE(P); elements of this set are called tests. The meaning function is extended to BE(P) in the obvious way. We extend μ also from F to F^{∗} by defining μ(Λ) to be the identity on C and by setting μ(fϕ) = μ(ϕ) ∘ μ(f) for ϕ ∈ F^{∗} and f ∈ F.

2.1. Example. The storage type push-down, denoted PD, is defined by PD = (C, C_{in}, P, F, μ), where C = Γ^{+}, for a fixed infinite set Γ (of push-down symbols), C_{in} = Γ, P = {top = γ|γ ∈ Γ} ∪ {bottom}, F = {push(γ)|γ ∈ Γ} ∪ {pop}, and, for c = au with a ∈ Γ and u ∈ Γ^{∗}, μ(top = γ)(c) = true iff γ = a, μ(bottom)(c) = true iff u = Λ, μ(push(γ))(c) = γc, μ(pop)(c) = u if u ≠ Λ, and undefined otherwise.

The storage type counter is CTR = (N, {0}, {zero}, {incr, decr}, μ), where, for n ∈ N, μ(zero)(n) = true iff n = 0, μ(incr)(n) = n + 1, and μ(decr)(n) = n − 1 if n ≥ 1, and undefined if n = 0.

In the rest of this paper let X = (C, C_{in}, P, F, μ) be an arbitrary storage type.

An X-transducer is a construct A = (Q, Σ, δ, q_{in}, c_{in}, Δ), where Q is the finite set of states, Σ(Δ) is the input (output) alphabet, q_{in} ∈ Q is the initial state, c_{in} ∈ C_{in} is the initial storage configuration, and the finite control δ is a finite subset of Q × (Σ ∪ {Λ}) × BE(P) × Q × F^{∗} × Δ^{∗}, the elements of which are called transitions. We say that A is real-time if δ ⊆ Q × Σ × BE(P) × Q × F^{∗} × Δ^{∗}. A is deterministic if, for every two different transitions (q_{i}, a_{i}, β_{i}, q′_{i}, ϕ_{i}, w_{i}), i = 1, 2, from δ with q_{1} = q_{2}, either a_{1} ≠ a_{2} and a_{1}, a_{2} ≠ Λ or μ(β_{1} ∧ β_{2})(c) = false for every c ∈ C.

An instantaneous description (ID) of A is an element (q, x, c, y) of Q × Σ^{∗} × C × Δ^{∗}; it intuitively means that A is in state q, has read x from the input tape, has c as its storage configuration, and has written y on its output tape. The step relation ⊢_{A} of A, is the binary relation on Q × Σ^{∗} × C × Δ^{∗} defined by (q, x, c, y) ⊢_{A} (q′, x′, c′, y′) if there exists a transition (q, a, β, q′, ϕ, w) ∈ δ such that μ(β)(c) = true, c′ = μ(ϕ)(c), x′ = xa, and y′ = yw. Intuitively this means that if A is in state q and has the storage configuration c, it may use the transition (q, a, β, q′, ϕ, w) provided c satisfies the test β, and then it changes its state to q′, reads a from its input tape, performs ϕ to the storage configuration, and writes w on its output tape.

A (infinite) run of A is an infinite sequence r = ⟨τ_{i}⟩_{i∈N} of ID’s such that τ_{0} = (q_{in}, Λ, c_{in}, Λ), and τ_{i} ⊢_{A} τ_{i+1} for each i ∈ N; it is a run on input lub⟨x_{i}⟩_{i∈N}, and with output lub⟨y_{i}⟩_{i∈N} where τ_{i} = (q_{i}, x_{i}, c_{i}, y_{i}). The sequence ⟨q_{i}⟩_{i∈N} is called the state sequence of the run r.

The (infinitary) transduction of A, denoted T (A), is defined as {(u, v) ∈ Σ^{ω} × Δ^{ω}| there is a run of A on input u with output v}. If A has no run on an infinite input word with a finite output word, then A is called ω-preserving. XT (XT_{ω}) denotes the family of infinitary transductions of (ω-preserving) X-transducers. The corresponding families of transductions of deterministic or real-time X-transducers are denoted by d-XT (d-XT_{ω}) and r-XT (r-XT_{ω}), respectively.

2.2. (σ,ρ)-Accepting Infinite Runs

We will now discuss how an X-transducer A may be used to accept ωlanguages. Since, in this case, we are not interested in A’s output, A is called an X-automaton. We drop the output component from A, and from its transitions and ID’s.

Let Q be a set and let f be a mapping N → Q (i.e., an infinite sequence ⟨f(i)⟩_{i∈N} over Q). The range of f is the set ran(f) = {q ∈ Q|f(i) = q for some i ∈ N}; the infinity set of f is the set in(f) = {q ∈ Q|f(i) = q for infinitely many i ∈ N}.

Let D ⊆ 2^{Q} be a family of subsets of Q. Let ρ be one of the relations ⊆, ⊓ or =, and let σ be either ran or in. We say that an infinite sequence f : N → Q is (σ, ρ)-accepting with respect to D if there exists a set D ∈ D such that σ(f)ρD.

The relation between the notation we use (see [StaWag74]) and the five types of ‘i-acceptance’ as originally defined in [Lan69] are given in the following table, together with a short intuitive name for some of these types of acceptance. (ran, =)-acceptance, not considered by Landweber, was first studied in [StaWag74].

(ran, ⊓) 1-accepting  at least once
(ran, ⊆) 1′-accepting  always
(ran, =)  —
(in, ⊓) 2-accepting infinitely often (Büchi)
(in, ⊆) 2′-accepting from some moment on
(in, =) 3-accepting  (Muller)

Let A = (Q, Σ, δ, q_{in}, c_{in}) be an X-automaton, and let D ⊆ 2^{Q} be a family of subsets of Q. A run of A is called (σ, ρ)-accepting with respect to D if its state sequence is (σ, ρ)-accepting with respect to D.

The ω-language (σ, ρ)-accepted by A with respect to D, denoted by L_{σ,ρ}(A, D), is the set {u ∈ Σ^{ω}| there is a run of A on input u that is (σ, ρ)-accepting with respect to D}. The family of ω-languages (σ, ρ)- accepted by X-automata (with respect to some family of state sets) is denoted by XL_{σ,ρ}. Again we use the prefixes d- or r- if we restrict our considerations to deterministic or real-time automata. Finally, for a set D of states of A, the (finitary) language L_{∗}(A, D) accepted by A with respect to D is the set {x ∈ Σ^{∗}|(q_{in}, Λ, c_{in}) ⊢_{A}^{∗} (q, x, c) for some q ∈ D and c ∈ C}, where ⊢_{A}^{∗} is the reflexive and transitive closure of ⊢_{A}.

In the literature it is sometimes required that A is ‘total’, e.g., in the sense that A has a run on every input word. We will not consider totality. Requiring totality changes (in general) the class XL_{σ,ρ}.

A special storage type is used to model finite state automata. The trivial storage type FS equals ({c0}, {c0}, ∅, ∅, ∅) for some arbitrary object c0. Since ∅^{∗} = {Λ} the transitions of an FS-automaton can be assumed to be of the form (q, a, true, q′, Λ).

2.2. Example. Let A be the (deterministic and real-time) FS-automaton with state set Q = {q_{0}, q_{1}}, input alphabet Σ = {0, 1}, initial state q_{0}, and transitions (q_{i}, j, true, q_{j}, Λ) for i, j ∈ {0, 1}. Let D = {{q_{1}}}, and Q = {Q}. Then

L_{ran,⊓}(A, D) = 0^{∗}1 · {0, 1}^{ω}

L_{ran,⊓}(A, Q) = L_{ran,⊆}(A, Q) = {0, 1}^{ω},

L_{ran,⊆}(A, D) = L_{ran,=}(A, D) = ∅,

L_{ran,=}(A, Q) = 0^{∗}1 · {0, 1}^{ω},

L_{in,⊓}(A, D) = (0^{∗}1)^{ω},

L_{in,⊓}(A, Q) = L_{in,⊆}(A, Q) = {0, 1}^{ω},

L_{in,⊆}(A, D) = L_{in,=}(A, D) = {0, 1}^{∗} · 1^{ω}, L_{in,=}(A, Q) = (0^{∗}11^{∗}0)^{ω}.

It is customary in the literature to define regular ω-languages using real-time finite state automata. It can be shown that this restriction does not influence the families of (σ, ρ)-accepted finite state ω-languages, i.e., FSL_{σ,ρ} = r-FSL_{σ,ρ} and d-FSL_{σ,ρ} = dr-FSL_{σ,ρ}. Hence we have the following well-known relationships for these families (see, e.g., [Wag79] for references). Note that → denotes proper inclusion.

2.3. Proposition.

FSL_{in,⊓}
∥
FSL_{ran,⊆}  FSL_{ran,⊓} = FSL_{ran,=} = FSL_{in,⊆}  FSL_{in,=}
∥  ∥  ∥
∥  d-FSL_{in,⊆}  ∥
d-FSL_{ran,⊆} → d-FSL_{ran,⊓} → d-FSL_{ran,=} {↗ \atop ↘}  {↘ \atop ↗} d-FSL_{in,=}
d-FSL_{in,⊓}

Note that when requiring totality the diagram is slightly different, caused by the fact that FSL_{ran,⊓} and d-FSL_{ran,⊓} become smaller.

Finally we need (but do not define formally) the notion of the product of two storage types X_{1} and X_{2}, denoted by X_{1}×X_{2}. It combines the power of the two storages X_{1} and X_{2} working in an independent fashion. Thus, e.g., the CTR×CTR-automaton is the well-known two-counter automaton. The product of n storage types, all equal to X, is denoted by X^{n}. An X^{∗}-automaton is an X^{n}-automaton for some n ∈ N. Thus, e.g., each CTR^{∗}-automaton has an arbitrary (but fixed) number of counters.

3. The Basic Characterization

In the next lemma we show how to separate an X-automaton in two phases: a phase in which the input is processed, and an acceptance phase. The first phase can be realized by an X-transducer (without acceptance criterion), and the second phase by a finite state automaton.

3.1. Lemma. XL_{σ,ρ} ⊆ XT_{ω}^{−1}(d-FSL_{σ,ρ}) and d-XL_{σ,ρ} ⊆ d-XT_{ω}^{−1}(d-FSL_{σ,ρ}).

Proof. Let A be an X-automaton with input alphabet Σ and state set Q; let D be a family of state sets for A. Consider the infinitary language K(σ, ρ) consisting of the ω-words over Q that are (σ, ρ)-accepting sequences wrt. D. It belongs to d-FSL_{σ,ρ} since it is (σ, ρ)-accepted by the deterministic finite state automaton B = (Q∪{q^{o}}, Q, δ_{1}, q^{o}, c0) with q^{o} ∉ Q and δ_{1} = {(q′, q, true, q, Λ)|q′ ∈ Q ∪ {q^{o}}, q ∈ Q}. One easily sees that for r ∈ Q^{ω}, the run r_{1} of B on r satisfies ran(r_{1}) = ran(r)∪{q^{o}} and in(r_{1}) = in(r). Thus K(σ, ρ) = L_{σ,ρ}(B, D^{o}) with D^{o} = {D∪{q^{o}}|D ∈ D} if (σ, ρ) equals (ran, =) or (ran, ⊆), and K(σ, ρ) = L_{σ,ρ}(B, D) in the four remaining cases.

Modify A such that at each step it outputs its state, i.e., take Δ = Q and replace every transition (q, a, β, q′, ϕ) by the transition (q, a, β, q′, ϕ, q). This gives an (ω-preserving) X-transducer M that maps each ω-word u over Σ onto the state sequences of the runs of A on u. u is (σ, ρ)- accepted by A if one of these state sequences belongs to K(σ, ρ). Hence, L_{σ,ρ}(A, D) = {u ∈ Σ^{ω}|(u, r) ∈ T (M) for some r ∈ K(σ, ρ)} = T (M)^{−1} (K(σ, ρ)).

3.2. Lemma. For storage types X_{1} and X_{2}, X_{1}T_{ω}^{−1}(X_{2}L_{σ,ρ}) ⊆ (X_{1} × X_{2})L_{σ,ρ} and d-X_{1}T_{ω}^{−1}(d-X_{2}L_{σ,ρ}) ⊆ d-(X_{1} × X_{2})L_{σ,ρ}.

Proof. Let M be an ω-preserving X_{1}-transducer with input alphabet Σ, let A be an X_{2}-automaton with a family of state sets D. The lemma is proved by constructing an X_{1} × X_{2}-automaton B that (σ, ρ)-accepts the ω-language T (M)^{−1}(L_{σ,ρ}(A, D)) = {u ∈ Σ_{1}^{ω}|(u, v) ∈ T (M) for some v ∈ L_{σ,ρ}(A, D)}. Using a straightforward direct product construction we simulate M and A in two alternating phases: first we simulate M until it produces some nonempty output and we store this output in the states of B, then we simulate A on this output. Using such a simulation, a run r_{B} of B on an ω-word u can be decomposed into a run of M on u and an infinite run r_{A} of A on the output v of M. Here the fact that M is ω-preserving is essential in order to guarantee that v is infinite. If we restrict the state sequence of r_{B} to the component of the states corresponding to A, it is equal (except for possible repetitions) to the state sequence of r_{A}. This observation can be used to obtain a suitable family of state sets D′ for B. Some care has to be taken: D′ depends on the acceptance type.

If we combine these lemma’s we obtain our basic result: a characterization of the families XL_{σ,ρ} and d-XL_{σ,ρ} in terms of X-transductions and finite state ω-languages.

3.3. Theorem. XL_{σ,ρ} = XT_{ω}^{−1}(FSL_{σ,ρ}) and d-XL_{σ,ρ} = d-XT_{ω}^{−1}(d-FSL_{σ,ρ})

Proof. For X_{1} = X and X_{2} = FS we get XL_{σ,ρ} ⊆ XT_{ω}^{−1}(FSL_{σ,ρ}) ⊆ (X × FS)L_{σ,ρ} ⊆ XL_{σ,ρ}.

For some of the acceptance conditions the family FSL_{σ,ρ} can be replaced by a single ω-language. Intuitively this ω-language models the acceptance condition. A similar result was obtained in [WagSta77] for ωlanguages accepted by Turing machines, and (implicitly) in [LatTim86] for regular ω-languages.

3.4. Theorem. XL_{ran,⊆} = XT_{ω}^{−1}({1^{ω}}), XL_{ran,⊓} = XT_{ω}^{−1}({0^{∗}1 · {0, 1}^{ω}}), XL_{in,⊆} = XT_{ω}^{−1}({{0, 1}^{∗}·1^{ω}}), and XL_{in,⊓} = XT_{ω}^{−1}({(0^{∗}1)^{ω}}). Similar equalities hold for d-XL_{σ,ρ} and d-XT_{ω}^{−1}.

Proof. For ρ ∈ {⊆, ⊓} we may assume that L ∈ XL_{σ,ρ} is accepted by an X-automaton with respect to a family D = {D} (cf. [CohGol78a, Lemma 4.1.2]). Now (as in the proof of Lemma 3.1) change A into an X-transducer M that outputs 1 if its state is in D, and 0 otherwise.

Using Theorem 3.3, we can carry over the known inclusions for the families FSL_{σ,ρ} (see Proposition 2.3) directly to the families XL_{σ,ρ} for arbitrary X, without being forced to generalize the proofs for FS-automata. Thus we obtain our next main result.

3.5. Theorem. XL_{ran,⊆} ⊆ XL_{ran,⊓} = XL_{ran,=} = XL_{in,⊆} ⊆ XL_{in,⊓} = XL_{in,=}.

The corresponding result for deterministic automata will be presented in Section 5. We cannot conclude that the inclusions are strict in general like for finite state ω-languages (X = FS, Proposition 2.3) or push-down automata (X = PD, [CohGol77]). In fact, for certain storage types all six families XL_{σ,ρ} are equal (e.g., for Turing machines, see [CohGol78b]). In the remainder of this section we give a sufficient condition on X for all six families to be equal. It is based on the inclusion FSL_{in,⊓} ⊆ PDL_{ran,⊆}, which was proved in [CohGol77] using the pushdown as a counter.

The storage type blind counter, denoted by BC, is equal to the storage type counter (see Example 2.1), except that it has no predicate symbols (cf. [Gre78] where it is called a partially blind counter).

3.6. Lemma. XL_{in,⊓} ⊆ (X × BC)L_{ran,⊆}.

Proof. By Theorem 3.4, XL_{in,⊓} = XT_{ω}^{−1}({(0^{∗}1)^{ω}}), while XT_{ω}^{−1}(BCL_{ran,⊆}) ⊆ (X × BC)L_{ran,⊆}, by Lemma 3.2. Hence it suffices to show that (0^{∗}1)^{ω} ∈ BCL_{ran,⊆}. We construct a BC-automaton A that uses its (blind) counter to ensure that during its runs it can read any finite number of consecutive 0’s, but not infinitely many consecutive 0’s. A has two states q_{0} and q_{1} and, for i = 0, 1, transitions (q_{i}, 0, true, q_{0}, decr) and (q_{i}, 1, true, q_{1}, Λ), and the transition (q_{1}, Λ, true, q_{1}, incr). The initial state of A is q_{1}. Take D = {{q_{0}, q_{1}}}. For each step on the letter 0 A decreases its counter. Whenever A reads the letter 1 it enters state q_{1}. In this state, before reading the next input letter, A guesses the number of 0’s on the tape before the next 1, and increases its counter value by (at least) this amount.

Hence, if the storage type X can simulate an additional blind counter, all XL_{σ,ρ} are the same.

3.7. Theorem. If X can simulate X×BC, in the sense that (X×BC)L_{ran,⊆} ⊆ XL_{ran,⊆}, then XL_{ran,⊆} = XL_{in,⊓}.

Using this result we clearly reobtain the equality of the families of ω-languages (σ, ρ)-accepted by Turing machines ([CohGol78b]).

It is obvious that the storage type BC^{∗} can simulate an additional blind counter. Hence for Petri net ω-languages, with acceptance with respect to bounded markings (cf. [Val83]), and Λ-labels allowed, the six families BC^{∗}L_{σ,ρ} are all equal. Although these families were not (explicitly) compared in the literature, the inclusion r-BC^{∗}L_{in,⊓} ⊆ BC^{∗}L_{ran,⊆} is known (see [Car88, Theorem 3]).

4. Real-Time Automata

As in Section 3, we obtain a characterization of the families r-XL_{σ,ρ} in terms of X-transductions and finite state ω-languages. The proofs are slight variations of those of Lemma’s 3.1 and 3.2.

4.1. Theorem. r-XL_{σ,ρ} = r-XT_{ω}^{−1}(FSL_{σ,ρ}).

This allows us, as in Section 3, to transfer the inclusions known for the families FSL_{σ,ρ} directly to the families r-XL_{σ,ρ}. Again we investigate when the remaining two inclusions are equalities and when they are strict. Perhaps somewhat surprisingly they turn out to be always strict, as shown next.

4.2. Lemma. Let A be a real-time X-automaton, with state set Q. Then L_{ran,⊆}(A, {Q}) = adh(L_{∗}(A, Q)).

Proof. Let L = L_{∗}(A, Q). Note that L_{ran,⊆}(A, {Q}) is the set of all ωwords on which there exists a run of A, without additional requirements on its state sequence. Assume that u ∈ L_{ran,⊆}(A, {Q}). This implies that u[n] ∈ L for each n ∈ N and consequently u ∈ adh(L). To prove the other inclusion let u ∈ adh(L). Thus for each n ∈ N A accepts the prefix u[n] of u. Define the sets E_{n}, n ∈ N, of ID’s of A that are reachable from the initial ID after reading u[n]. Since each of these sets is finite and nonempty, König’s Lemma can be used to obtain a run of A on u.

4.3. Lemma. (1) r-XL_{ran,⊆} ⊆ F and (2) r-XL_{in,⊆} ⊆ F_{σ}.

Proof. Since F and F_{σ} are closed under union, it suffices to consider ω-languages (σ, ρ)-accepted with respect to a single state set. Let A = (Q, Σ, δ, q_{in}, c_{in}) be a real-time X-automaton and let D ⊆ Q. L_{ran,⊆}(A, {D}) does not change by restricting A to the states from D. Hence (1) is a consequence of the lemma above.

Each (in, ⊆)-accepting state sequence (w.r.t. {D}) of A falls apart into an initial part without restrictions, followed by an infinite part that stays within D. Thus

L_{in,⊆}(A, {D}) = ⋃_{(q_{in},Λ,c_{in})⊢^{∗}(q,x,c)} L_{ran,⊆}(A(q, x, c), {D ∪ Q_{q,x,c}}),

where A(q, x, c) equals A, except that it has a new set of transitions, leading from a new initial state q_{in} to q, reading x from the input, and transforming c_{in} into c — these transitions copy the computation (q_{in}, Λ, c_{in}) ⊢_{A}^{∗} (q, x, c). Q_{q,x,c} is the set of states that were added to obtain A(q, x, c). The above union is countable. Hence, by (1), every ω-language in r-XL_{in,⊆} is a countable union of F-sets, thus an F_{σ}-set.

These topological upper-bounds yield examples to show that the remaining two inclusions are strict for every storage type. Thus we obtain the next main result.

4.4. Theorem. r-XL_{ran,⊆} ⊂ r-XL_{ran,⊓} = r-XL_{ran,=} = r-XL_{in,⊆} ⊂ r-XL_{in,⊓} = r-XL_{in,=}.

Proof. According to Proposition 1.2, 0^{∗}1 · {0, 1}^{ω} ∉ F ⊇ r-XL_{ran,⊆}; however 0^{∗}1 · {0, 1}^{ω} ∈ r-XL_{ran,⊓} (cf. Example 2.2). In the same way we have (0^{∗}1)^{ω} ∉ F_{σ} ⊇ r-XL_{in,⊆}, whereas (0^{∗}1)^{ω} ∈ r-XL_{in,⊓}.

Perhaps one of the main reasons for obtaining the strict inclusions above, is that König’s Lemma is applicable to real-time automata (Lemma 4.2). This argumentation can be extended to a larger class of automata. An X-automaton A has finite delay if there is no infinite run of A on a finite word. All results for real-time automata proved in this section also hold for automata with finite delay. We use the prefix f- to indicate finite delay.

In general the families f-XL_{σ,ρ} and r-XL_{σ,ρ} are not equal. The ωlanguage BIN_{ω} = {x · a^{k}|x ∈ {0, 1}^{∗}, 0 ≤ k ≤ nr(x)} · b^{ω} ∪ {0, 1}^{ω}, where nr(x) denotes the integer represented by x ∈ {0, 1}^{∗} as a binary number, can be accepted by a BC^{2}-automaton with finite delay but not by a real-time BC^{∗}-automaton. More precisely, BIN_{ω} ∈ f-BC^{2}L_{ran,⊆} − r-BC^{∗}L_{in,⊓}. This example is essentially the one given by Jantzen ([Jan79]) to show that Λ-labelled Petri nets are more powerful than real-time Petri nets (when accepting finitary languages). It is perhaps interesting to note that Petri nets with finite delay were considered in the context of ω-languages. In [Car84] these nets are called prompt nets. This paper however focusses on nets that are 1-prompt, i.e., nets in which Λ-transitions are allowed, but not two consecutive Λ-transitions in a firing sequence (run). From our previous results it now follows that the following diagram holds for Petri nets (with acceptance with respect to bounded places, see [Val83] for real-time nets). We conjecture that the indicated inclusion (⇑) is an equality.

4.5 Theorem.

BC^{∗}L_{ran,⊆}  =  BC^{∗}L_{ran,⊓}  =  BC^{∗}L_{in,⊓}
⇑
f − BC^{∗}L_{ran,⊆} → f − BC^{∗}L_{ran,⊓} → f − BC^{∗}L_{in,⊓}
↑ ↑ ↑
r − BC^{∗}L_{ran,⊆} → r − BC^{∗}L_{ran,⊓} → r − BC^{∗}L_{in,⊓}

5. Deterministic Automata

In this section we return to deterministic automata. Again we show that the diagram for d-FSL_{σ,ρ} (Proposition 2.3) holds for arbitrary d-XL_{σ,ρ}.

5.1. Lemma. Let A be a deterministic X-automaton with state set Q and input alphabet Σ, and let D ⊆ 2^{Q}. Then

(1) L_{ran,⊆}(A, {Q})) = adh(L_{∗}(A, Q)),

(2) L_{ran,⊓}(A, D) = L_{∗}(A, ∪D) · Σ^{ω} ∩ adh(L_{∗}(A, Q)), and

(3) L_{in,⊓}(A, D) = lim(L_{∗}(A, ∪D)).

The above (simple) result enables us to give topological upper-bounds on the ω-languages that are accepted by deterministic automata. Given two families K and L, K ∧ L denotes {K ∩ L|K ∈ K, L ∈ L}, and B(K) denotes the boolean closure of K.

5.2. Corollary. (1) d-XL_{ran,⊆} ⊆ F,

(2) d-XL_{ran,⊓} ⊆ F ∧ G,

(3) d-XL_{ran,=} ⊆ B(F),

(4) d-XL_{in,⊆} ⊆ F_{σ},

(5) d-XL_{in,⊓} ⊆ G_{δ}, and

(6) d-XL_{in,=} ⊆ B(F_{σ}).

Proof. (1,2,5) These are clear from Lemma 5.1.

(4) Can be shown just as the inclusion r-XL_{in,⊆} ⊆ F_{σ} in Lemma 4.3. (3,6) Consider an arbitrary deterministic X-automaton A and a family D of state sets for A. Then L_{σ,=}(A, D) = ⋃_{D∈D}(L_{σ,⊆}(A, {D}) − L_{σ,⊓}(A, {Q − D})). Now d-XL_{ran,=} ⊆ B(F) and d-XL_{in,=} ⊆ B(F_{σ}) follow.

5.3. Lemma. {0, 1}^{ω} − 0^{∗}1 · 0^{ω} ∉ F ∧ G.

Proof. Assume that K = {0, 1}^{ω} − 0^{∗}1 · 0^{ω} is of the form L_{1} · {0, 1}^{ω}∩ adh(L_{2}) for finitary languages L_{1} and L_{2}. Since 0^{ω} ∈ K ⊆ L_{1} · {0, 1}^{ω}, we have 0^{n} ∈ L_{1} for some n ∈ N. On the other hand 0^{n}10^{∗}1 · 0^{ω} ⊆ K ⊆ adh(L_{2}), so pref (0^{n}10^{∗}) ⊆ pref (L_{2}). Consequently 0^{n}1 · 0^{ω} ∈ L_{1} · {0, 1}^{ω} ∩ adh(L_{2}) = K; a contradiction.

We now present the next main result.

5.4. Theorem. The following diagram holds:

d-XL_{in,⊆}
d-XL_{ran,⊆} → d-XL_{ran,⊓} → d-XL_{ran,=} {↗ \atop ↘}  {↘ \atop ↗} d-XL_{in,=}
d-XL_{in,⊓}

Proof. The inclusions follow from Proposition 2.3 and Theorem 3.3. Using the topological upper-bounds we have obtained, we find (using Proposition 1.2 and Lemma 5.3) that 0^{∗}1·{0, 1}^{ω} ∉ d-XL_{ran,⊆}, {0, 1}^{ω} − 0^{∗}1 · 0^{ω} ∉ d-XL_{ran,⊓}, (0^{∗}1)^{ω} ∉ d-XL_{in,⊆}, and {0, 1}^{∗} · 1^{ω} ∉ d-XL_{in,⊓}. However these ω-languages are in respectively d-XL_{ran,⊓}, d-XL_{ran,=}, d-XL_{in,⊓}, and d-XL_{in,⊆}, as the reader will easily verify. From these observations the strictness of the inclusions (and the incomparabilities) follow.

For some of the storages studied in the literature it was observed that the families d-XL_{in,⊆} and d-XL_{in,⊓} are ‘complementary’, i.e., one contains the complements of the ω-languages of the other. This is due to the fact that automata are often assumed to be ‘total’, i.e., they should have a run on every possible input (this is called the continuity property in [CohGol77]). Since we do not have this requirement we cannot derive such a result for arbitrary X-automata. Instead, we need the following notion which previously has been quite helpful in complementing the finitary languages accepted by deterministic X-automata (cf. [EngVog87]).

5.5. Definition. Let X = (C, C_{in}, P, F, μ) be a storage type. X with infinite look-ahead, denoted X_{ωLA}, is the storage type (C, C_{in}, P′, F, μ′), where P′ = P ∪ {inf(A)|A is an X-automaton}, with μ′(x) = μ(x) for each x ∈ P ∪ F, and μ′(inf(A))(c) = true if and only if there exists an infinite run of A on Λ starting from (q_{in}, Λ, c), where q_{in} is A’s initial state.

5.6. Lemma. Let L ⊆ Σ^{ω}.

(1) If L ∈ d-XL_{σ,=}, then Σ^{ω} − L ∈ d-X_{ωLA}L_{σ,=}.

(2) If L ∈ d-XL_{in,⊆} then Σ^{ω} − L ∈ d-X_{ωLA}L_{in,⊓}.

(3) If L ∈ d-XL_{in,⊓} then Σ^{ω} − L ∈ d-X_{ωLA}L_{in,⊆}. Proof. Let A = (Q, Σ, δ, q_{in}, c_{in}) be a deterministic X-automaton. For (in, ⊆) and (in, ⊓)-acceptance we may assume that we have a single state set D with respect to which we accept runs. If A has a run on each u in Σ^{ω}, then Σ^{ω} − L_{in,⊓}(A, {D}) = L_{in,⊆}(A, {Q − D}). Similarly, the complement with respect to Σ^{ω} of the ω-language L_{σ,=}(A, D) is equal to L_{σ,=}(A, 2^{Q} −D), provided that for each ω-word u in Σ^{ω} there is a run of A on u. Using infinite look-ahead A may be transformed in such a way that it satisfies this property. We add a special state q_{fail} to A, with transitions (q_{fail}, a,true,q_{fail}, Λ) for each a ∈ Σ, to which we will lead all ‘unsuccessful runs’. There are several possibilities for the behaviour of A on u to be ’unsuccessful’.

(a) A blocks due to an undefined instruction. We can avoid that by testing the instruction as follows. For ϕ ∈ F^{∗}, consider the X-automaton B(ϕ) consisting of two states q_{0} and q_{loop} (of which q_{0} is initial), and having two transitions (q_{0}, Λ,true,q_{loop}, ϕ) and (q_{loop}, Λ,true,q_{loop}, Λ). B(ϕ) has a run on Λ starting from (q_{0}, Λ, c) if and only if μ(ϕ)(c) is defined. Now replace in A each transition (q, a, β, q′, ϕ) by transitions (q, a, β ∧ inf(B(ϕ)), q′, ϕ) and (q, a, β ∧ ¬ inf(B(ϕ)), q_{fail}, Λ).

(b) A has a run on a finite prefix of u. Replace in A each transition (q, a, β, q′, ϕ) by transitions (q, a, β ∧¬ inf(A(q)), q′, ϕ) and (q, a, β ∧ inf(A(q)), q_{fail}, Λ), where A(q) is the X-automaton that equals A, except that its initial state is q.

(c) Finally A may block because in some ID there are no ‘useful’ transitions: the present configuration satisfies none of the tests of the transitions that start in the present state (with a suitable input). This case is left to the reader.

Note that if X_{ωLA} can be simulated by X (and this holds, e.g., for X = FS and X = PD), then the previous lemma shows that d-XL_{σ,=} is closed under complement, and that d-XL_{in,⊆} and d-XL_{in,⊓} contain the complements of each others ω-languages. In the next section we need this property for a specific storage type.

6. A Universal Storage Type

In this section we show the existence of a storage type of ‘maximal power’.

6.1. Definition. The universal storage type U equals (Γ^{∗}, {Λ}, P, F, μ), where Γ is a fixed infinite set of symbols, P = {inK|K ⊆ Σ^{∗}, for a finite Σ ⊆ Γ}, F = {store(x)|x ∈ Γ^{∗}}, and, for c ∈ Γ^{∗}, μ(inK)(c) = true iff c ∈ K, and μ(store(x))(c) = cx.

6.2. Lemma. For every storage type X, U can simulate X, in the sense that XL_{σ,ρ} ⊆ UL_{σ,ρ}, and similarly for d- and r-.

Proof. Let X = (C, C_{in}, P, F, μ) and let A be a X-automaton with initial configuration c_{in}. We will construct a U-automaton A′ with the same behaviour. We use the configurations of U to store the sequences of instruction symbols that are performed by A and encode those sequences that lead to configurations in which a given test is satisfied in a suitable language. Let F_{A} be the (finite) subset of F of instruction symbols that are used in A. Without restriction we may assume that F_{A} is included in Γ, the alphabet of U. Let, for ϕ ∈ F^{∗}, Def(ϕ) = {ψ ∈ F_{A}^{∗}|μ(ψ · ϕ)(c_{in}) is defined} and, for β ∈ BE(P), let True(β) = {ψ ∈ F_{A}^{∗}|c = μ(ψ)(c_{in}) is defined and μ(β)(c) = true}. Now A′ is obtained by replacing every transition (q, a, β, q′, ϕ) of A by the transition (q, a, inTrue(β) ∧ inDef(ϕ), q′, store(ϕ)).

6.3. Theorem. (1) d-UL_{ran,⊆} = F,

(2) d-UL_{ran,⊓} = F ∧ G,

(3) d-UL_{ran,=} = B(F),

(4) d-UL_{in,⊆} = F_{σ},

(5) d-UL_{in,⊓} = G_{δ}, and

(6) d-UL_{in,=} = B(F_{σ}). Proof. The inclusions from left to right follow from Corollary 5.2. (1,5) Let A be the U-automaton with transitions (q_{i}, a, inK, q_{1}, store(a)) and (q_{i}, a, ¬inK, q_{0}, store(a)) for a ∈ Σ, i ∈ {0, 1}, and with initial state q_{1}. For this automaton L_{in,⊓}(A, {{q_{1}}}) = lim(K). This shows G_{δ} ⊆ d-UL_{in,⊓}. If K = pref (K), then L_{ran,⊆}(A, {{q_{1}}}) = adh(K), which shows F ⊆ d-UL_{ran,⊆}.

(2) Let B be the U-automaton with transitions (q_{0}, a, ¬inL, q_{0}, store(a)), (q_{0}, a, inL, q_{1}, store(a)), and (q_{1}, a, inK, q_{1}, store(a)) for a ∈ Σ, and with initial state q_{0}. If K = pref (K), then L_{ran,⊓}(A, {{q_{1}}}) = L · Σ^{ω} ∩ adh(K).

(3) For B(F) ⊆ d-UL_{ran,=} it suffices to show, by (1) above, that d-UL_{ran,=} is closed under complement and union. The closure of d-UL_{ran,=} under complement follows from Lemma 5.6 and Lemma 6.2. The closure of d-UL_{ran,=} under union can be shown using an easy direct product construction (using the fact that U can simulate U × U).

(4) F_{σ} ⊆ d-UL_{in,⊆} follows by complementation from (5) above (see Lemma 5.6).

(6) For B(F_{σ}) ⊆ d-UL_{in,=} we use an argumentation analogous to (3) above.

Note that these classes are related by the diagram in Theorem 5.4.

Thus in the deterministic case the maximal power of U can be expressed as a topological family, depending on the acceptance criterion. For finitary languages U is of no interest: every finitary language can be accepted by a deterministic real-time U-automaton.

6.4. Theorem. (1) dr-UT = d-UT equals the family of continuous functions with domain in G_{δ}.

(2) dr-UT_{ω} = d-UT_{ω} equals the family of continuous functions with domain in F.

Proof. Recall that the function f : Σ^{ω} → Δ^{ω} is continuous in a word u if for each m ∈ N there exists n ∈ N such that f(u[n]·Σ^{ω}) ⊆ f(u)[m]·Δ^{ω}. If (u, v) ∈ T (M) for some deterministic transducer M, and M outputs the first m symbols of v on the first n symbols of u, then T (M)(u[n] · Σ^{ω}) ⊆ v[m] · Δ^{ω}, where Σ and Δ are the input alphabet and output alphabet of M. Hence T (M) is continuous. Regarding the domain of transductions it can be shown that dom(d-UT) = d-UL_{in,⊓} = G_{δ}, and dom(d-UT_{ω}) = d-UL_{ran,⊆} = F. We omit the proof of the reverse inclusions.

6.5. Theorem. UL_{σ,ρ} equals the family of continuous images of G_{δ}-sets.

Proof. By Theorem 3.7 and Lemma 6.2 the UL_{σ,ρ} are all equal. It is easy to see that UL_{in,⊓} ⊆ dr-FST(d-UL_{in,⊓}). Hence each set in UL_{in,⊓} is the continuous image of the intersection of two G_{δ}-sets (the domain of the transducer and the d-UL_{in,⊓} set) which again is a G_{δ}-set. The continuous images of G_{δ}-sets are exactly the ranges of deterministic realtime U-transductions. The following easy inclusions hold: ran(dr-UT) ⊆ dom(dr-UT^{−1}) ⊆ dom(UT_{ω}) ⊆ UT_{ω}^{−1}(FSL_{in,⊓}). By Theorem 3.3 this is UL_{in,⊓}.

Without proof we state the topological characterizations of the families r-UL_{σ,ρ} (cf. Lemma 4.3). The same equalities hold for f-.

6.6. Theorem. r-UL_{ran,⊆} = F, r-UL_{in,⊆} = F_{σ}, and r-UL_{in,⊓} = UL_{in,⊓}.

Similar results were obtained by Arnold ([Arn83], cf. [Sta84]) for the more general framework of transition systems. He discusses the acceptance types (ran, ⊆), (in, ⊆), and (in, ⊓)—somewhat reformulated to deal with a possibly infinite number of states—for various kinds of transition systems. It is not difficult to see that Arnold’s deterministic, finitely branching, and countably branching transition systems correspond in our framework closely to automata that are deterministic, have finite delay, or are unrestricted, respectively. Note that his definitions do not allow Λ-transitions, whereas in our framework the number of transitions applicable to an ID of an automaton is bounded by a constant (depending on the automaton).

Acknowledgements

We would like to thank dr. Ludwig Staiger for his useful suggestions, prof. Wolfgang Thomas for several motivating discussions, and prof. Volker Diekert for his continuous enthousiasm and for organizing this ACMICS workshop on infinite traces.

References

[Arn83] A. Arnold, Topological characterizations of infinite behaviours of transition systems, LNCS 154 (1983) 28-38 Springer Verlag, Berlin.

[BoaNiv80] L. Boasson & N. Nivat, Adherences of languages, J. Comput. System Sci. 20 (1980) 285-309.

[Büc60] J.R. Büchi, On a decision method in restricted second order arithmetic, in: Proc. Int. Congr. Logic, Methodology and Philosophy of Sciences 1960, Stanford University Press, Stanford, CA, 1962.

[Car84] H. Carstensen, Fairness in deadlockfree Petri nets with the finite delay property, Proc 5th European Workshop on appl. and theory of Petri nets, Aarhus, 1984, pp. 234-253.

[Car88] H. Carstensen, Infinite behaviour of deterministic Petri nets, LNCS 324 (1988) 210-219 Springer Verlag, Berlin.

[CohGol77] R.S. Cohen, A.Y. Gold, Theory of ω-languages. II: A study of various models of ω-type generation and recognition, J. Comput. System Sci. 15 (1977) 185-208.

[CohGol78a] R.S. Cohen, A.Y. Gold, ω-Computations on deterministic pushdown machines, J. Comput. System Sci. 16 (1978) 275-300.

[CohGol78b] R.S. Cohen, A.Y. Gold, ω-Computations on Turing ma-

chines, Theor. Comput. Sci. 6 (1978) 1-23.

[Eil74] S. Eilenberg, Automata, languages and machines, Ch. XIV: Infinite behavior of finite automata, Academic Press, New York and London, 1974.

[EngHoo89] J. Engelfriet, H.J. Hoogebooom, Automata with storage on infinite words, in “Proceedings ICALP 1989” (G. Ausiello, M. Dezani-Ciancaglini, S. Ronchi Della Rocca, eds.) LNCS 372 (1989) 389-303, Springer Verlag, Berlin.

[EngVog87] J. Engelfriet, H. Vogler, Look-ahead on pushdowns, Inform. and Computation 73 (1987) 245-279.

[Gin75] S. Ginsburg, Algebraic and automata-theoretic properties of formal languages, 1975, North-Holland/American Elsevier, Amsterdam/New York.

[GinGre69] S. Ginsburg, S.A. Greibach, Abstract families of Languages, in “Studies in abstract families of languages”, Memoirs of the Amer.Math. Soc. 87 (1969) 1-32.

[Gre78] S.A. Greibach, Remarks on blind and partially blind one-way multicounter machines, Theor. Comput. Sci. 7 (1978) 311-324.

[HooRoz86] H.J. Hoogebooom, G. Rozenberg Infinitary languages – basic theory and applications to concurrent systems, in “Current trends in concurrency” (J.W. de Bakker, W.P. de Roever, G. Rozenberg, eds.) LNCS 224 (1986) 266-342, Springer Verlag, Berlin.

[Hos72] R. Hossley, Finite tree automata and ω-automata, MAC Technical report 102 MIT, summer 1972.

[HopUll67] J.E. Hopcroft, J.D. Ullman, An approach to a unified theory of automata, The Bell System Technical Journal XVLI (1967) 1793-1829.

[Jan79] M. Jantzen, On the hierarchy of Petri net Languages, RAIRO Inf. Théor. 13 (1979) 19-30.

[Lan69] L.H. Landweber, Decision problems for ω-automata, Math. Systems Theor. 3 (1969) 376-384.

[LatTim86] M. Latteux, E. Timmerman, Two characterizations of rational adherences, Theor. Comput. Sci. 46 (1986) 101-106.

[Lin76] M. Linna, On ω-sets associated with context-free languages, Inform. and Control 31 (1976) 272-293.

[Mul63] D.E. Muller, Infinite sequences and finite machines, AIEE Proc. 4th ann. symp. switch. circ. th. and log. design, 1963, pp.3-16.

[Sco67] D. Scott, Some definitional suggestions for automata theory, J. Comput. System Sci. 1 (1967) 187-212.

[Sta77] L. Staiger, Empty-storage-acceptance of ω-languages, LNCS 56 (1977) 516-521, Springer Verlag, Berlin.

[Sta84] L. Staiger, Projection lemmas for ω-languages, Theor. Comput. Sci. 32 (1984) 331-337.

[Sta87] L. Staiger, Research in the theory of ω-languages, EIK 23 (1987) 415-439.

[StaWag74] L. Staiger, K. Wagner, Automatentheoretische und automatenfreie Characterisierungen topologischer Klassen regulaerer Folgenmengen, EIK 10 (1974) 379-392.

[Tho88] W. Thomas, Automata on infinite objects, in “Handbook for Theoretical Computer Science” (J. van Leeuwen, ed.), North-Holland, 1991.

[Val83] R. Valk, Infinite behaviour of Petri nets, Theor. Comput. Sci. 25 (1983) 311-341.

[Wag79] K. Wagner, On ω-regular sets, Inform. and Control 43 (1979) 123-177.

[WagSta77] K. Wagner, L. Staiger, Recursive ω-languages, LNCS 56 (1977) 532-537, Springer Verlag, Berlin, see also: Rekursive Folgenmengen I, Zeitschr. math. Logik Grundlagen Math., 24 (1978) 523-528.

On logical definability of ω-trace languages ^{†}

Werner Ebinger

Universität Stuttgart Institut für Informatik Breitwiesenstr. 20–22 D 7000 Stuttgart 80

                    ebinger@informatik.uni-stuttgart.de

April 1992

Abstract

Our main result is the equivalence of monadic second order logic and recognizability for languages of infinite traces. This is a generalization of the work of Thomas [Tho90b]. We propose a logical characterization that is independent of any special sort of trace automata. For another approach we use standard constructions and Büchi asynchronous cellular automata defined by Gastin and Petit [GP91].

1 Introduction

On logical definability of ω-trace languages 107

The theory of ω-trace languages is a generalization of the theory of ωword languages [Tho90b, for an overview] and of the theory of trace languages [Maz77]. Both theories are well studied. ω-trace languages need some extra investigation, because there are new difficulties. The basic definitions of trace languages are explained well in other papers in these proceedings. So we only mention some important notions in this section.

†This research has been supported by the EBRA working group No. 3166 ASMICS.

In the second section we will give a short introduction to monadic second order logic. In the third section we will prove equivalence of monadic second order logic and recognizability for ω-trace languages. This is a generalization of the corresponding results for ω-words [Tho90a, for an overview] and finite traces [Tho90b]. We will provide a new proof that does not depend on any special sort of automata for infinite traces. In the fourth section we will recall the definition of the Büchi asynchronous automata of Gastin and Petit [GP91] and give a more classical proof of the equivalence of monadic second order logic and automata for ω-trace languages. In the fifth section we want to give some remarks on first order logic on ω-traces and star-free sets. Similar ideas have been proposed independently by Hoogeboom and Thomas. However, they never were worked out extensively.

We assume that the reader is familiar with the following notions of trace languages that can be found in other papers in this proceedings. In order to extend the free partially commutative monoid IM(Σ, D) [Maz77, Die90] over a dependence alphabet (Σ, D) to the infinite case, it is convenient to consider dependence graphs. In the monoid G(Σ, D) of infinite dependence graphs we consider the subset IR(Σ, D) of real traces where every node has a finite past, and the submonoid C(Σ, D) which is the quotient of G(Σ, D) by the coarsest congruence which preserves real traces [Die91]. We will use IM and IR as abbreviations for IM(Σ, D) and IR(Σ, D).

A language of real traces is called recognizable if it is recognized by some morphism η : IM → S into a finite monoid. A real trace language R ∈ IR is recognized by η if for any sequence (r_{i}), r_{i} ∈ IM we have

r_{1} r_{2} r_{3} … ∈ R ⇒ η^{−1}(η(r_{1})) η^{−1}(η(r_{2})) η^{−1}(η(r_{3})) … ⊆ R

The connection between recognizability for infinite traces and infinite words is given by [Gas91]

R ∈ Rec(IR) ⟺ φ^{−1}(R) ∈ Rec(Σ^{∞}),

where φ : Σ^{∞} → IR(Σ, D) is the extension of the canonical mapping to the infinite case.

2 Monadic second order logic over ω-traces

We can represent a real trace t ∈ IR(Σ, D) as a labeled partial order (V, <, ℓ). Logical formulae can be defined over a structure with signature (V, <, (P_{a})_{a∈Σ}). We use first order variables x, y, z, … ranging over V and monadic second order variables X, Y, Z, … ranging over P(V). Formulae are defined inductively:

• Predicates: First order predicates of the form x < y, P_{a}(x) and monadic second order predicates of the form X(x) are formulae for arbitrary variables x, y, X and all a ∈ Σ.

• Logical operations: If φ and ψ are formulae, then (φ ∧ ψ), (φ ∨ ψ), and (¬φ) are formulae, too.

• Quantifiers: If φ is a formula, then ∃xφ, ∀xφ, ∃Xφ, and ∀Xφ are formulae, too.

This monadic second order logic is called MSOL. We will also write z ∈ X instead of X(z) and freely use abbreviations like X ⊆ Y. Of course, we can also express x = y and X = Y in MSOL.

Example 1 We can express the property “t begins with b” by the formula

∃x(P_{b}(x) ∧ ∀y(x = y ∨ x < y)).
□

In monadic second order the power of the logic does not depend on the difference between the <-relation and the edge relation of the Hasse diagram of (V, <), which constitutes some kind of successor relation. The edge relation E of the Hasse diagram of (V, <) is expressible by < (even in first order logic):

x E y iff x < y ∧ ¬∃z(x < z ∧ z < y),

and vice versa (in monadic second order logic):

x < y iff ¬x = y ∧

∀X(x ∈ X ∧ \underbrace{∀z∀z′(z ∈ X ∧ z E z′ → z′ ∈ X)}_{If a node is in X, then all <-greater nodes are in X, too.}

→ y ∈ X)

Now we are free to use both, the <-relation and the edge relation E in monadic second order formulae.

Example 2

[figure: b; a; c; b; a; c; b; a; c; …]

Traces of the language T = (bac)^{ω} over the dependence alphabet D : a — b — c are described by the following formula. The parts in quotes can be easily replaced by a proper formula (even in first order).

“There is exactly one minimal node, labeled b.”

∧ “Every b-node has two successors, labeled a and c”
∧ “Every b-node except the minimal one has

two predecessors, labeled a and c”

∧ “Every a-node has exactly one predecessor and

one successor, both labeled b”

∧ “Every c-node has exactly one predecessor and

one successor, both labeled b”

□

In the fifth section we will go from formula to automata. These constructions can be simplified if we first reduce the logic MSOL to the restricted monadic second order logic MSOL_{0}. The logic MSOL_{0} is the logic MSOL with the restriction, that there are no first order variables. Instead of first order predicates we use only second order predicates of the form X_{i} ⊆ X_{j}, X_{i} < X_{j}, and X_{i} ⊆ P_{a}. Here X_{i} < X_{j} means X and Y are singleton sets and the element of X is smaller than the element of Y. As formulae grow really huge using only these basic predicates, we give the following abbreviations:

X = Y for X ⊆ Y ∧ Y ⊆ X
X ≠ Y for ¬X = Y
Sing(X) for ∃Y ( \overbrace{Y ⊆ X ∧ Y ≠ X}^{“proper subset”} ∧

\underbrace{¬∃Z(Z ⊆ X ∧ Z ≠ X ∧ Z ≠ Y)}_{“exactly one”} )

We now describe how to eliminate first order variables by giving an example. A formula like

\underline{∀x} ∃Y (x ∈ Y ∧ \underline{∃z}(x < z ∧ P_{a}(z))

is expressed as \underline{∀X(Sing(X) →} ∃Y (X ⊆ Y ∧ \underline{∃Z(Sing(Z) ∧} X < Z ∧ Z ⊆ P_{a})).

3 Equivalence of recognizability and logic

In this section we prove the equivalence of recognizability and logic. Our proof is independent of any special automata model for (infinite) traces. In the proof we will use c-rational trace languages [Och85, GPZ91] (also called co-rational). c-rational languages are defined inductively:

• All finite trace languages A ⊆ IM of finite traces are c-rational.

• If A ⊆ IM, B ⊆ IM, and C ⊆ IR are c-rational, then the concatenation A B and A C is c-rational.

• If A ⊆ IM is c-rational, then the concurrent iteration A^{c∗} (called coiteration by Ochmansky) and the concurrent ω-iteration A^{cω} are c-rational. For the concurrent iteration independent (connected) parts are iterated concurrently. This means A^{c∗} (A^{cω}) in the usual star (omega) iteration over C(A) = { t ∈ IM | t is a connected component of some s ∈ A }.

We can also use a constraint version of c-iteration were only connected parts may be iterated. This gives the same class of c-rational languages.

Theorem 3 A trace language T ⊆ IR(Σ, D) is recognizable if and only if T is definable in monadic second order logic.

Proof: The following figure shows what we have to prove. ⋃ T denotes the union of all traces t ∈ T, that is the word language that contains all members of traces in T. For the canonical mapping φ : Σ^{∞} → IR we have ⋃ T = φ^{−1}(T).

⋃ T is  ⋃ T is
definable  ⟺^{(Büchi)}  recog-
⟹^{(1)}  in MSOL  nizable  ⟺^{[Gas91]}
T is  T is
definable  recog-
in MSOL  nizable
⟸^{(2)} T is ⟺^{[GPZ91]}

c-rational

(1): We can not use the same formula for both, traces and words, as the underlying interpretation of the order is different. For example the formula

∃x, y, z P_{a}(x) ∧ P_{c}(y) ∧ P_{b}(z) ∧ x < z ∧ y < z ∧ (x < y ∨ y < x)

over the dependence alphabet D : a — b — c is not true for the trace acb, but it is true for both words in this trace. But it suffices to express the partial order on the traces by the linear order on the words. This can be done by one single first order formula, but in order to render it easier to follow, we proceed in two steps. We can first express the partial order by the edge relation E of the Hasse diagram of the dependence graph. This was described in the section on monadic second order logic. Then we express the edge relation E by the linear order on the words: x E y if and only if

⋁_{(a,b)∈D} (Q_{a}(x) ∧ Q_{b}(y) ∧ x < y

∧ ∀z (x < z ∧ z < y → ⋀_{c with ; (a, c) ∈ D or ; (b, c) ∈ D} ¬Q_{c}(z))).

Now if a trace t satisfies a formula φ, then all words w in the trace satisfy the new formula φ′, which we obtained by replacing the predicates x E y by the formula above. And vice versa if a word w ∈ t satisfies the new formula φ′, then all words w′ ∈ t in the same trace satisfy this new formula φ′, and the trace t containing this word w satisfies the original formula φ. We can formalize this using ⊧ as abbreviation of “is a model for”

t ⊧ φ ⟺ ∃w ∈ t w ⊧ φ′ ⟺ ∀w ∈ t w ⊧ φ′.

(2): For this implication of the diagram we perform an induction over the construction of concurrent rational (c-rational) expressions.

• A is a finite set of traces: We give a formula φ_{t} for every single word in A and combine them in a disjunction

φ_{A} = ⋁_{t∈A} φ_{t}.

• A ∪ B for c-rational sets A and B: Combine the formulae φ_{A} and

φ_{B} for A and B to

φ_{A∪B} = φ_{A} ∨ φ_{B}.

• A · B for c-rational sets A and B: For the formulae φ_{A} and φ_{B} we define formulae with restricted quantification. φ_{A}|_{X} for some set X is the formula φ_{A} where we replace every subformula ∃xψ by ∃x (x ∈ X ∧ψ), ∀xψ by ∀x (x ∈ X → ψ), ∃Y ψ by ∃Y (Y ⊆ X ∧ψ), and ∀Y ψ by ∃Y (Y ⊆ X → ψ). The formula φ_{A·B} is defined as

possible ; max./min. ; elements ; of A/B  ⋁_{{\{a_{1}, …, a_{k}\} \atop ⊆ Σ}} ⋁_{{\{b_{1}, …, b_{l}\} \atop ⊆ Σ}} ∃x_{a_{1}} … ∃x_{a_{k}}∃x_{b_{1}} … ∃x_{b_{l}}

incomparable  ( ⋀_{1 ≤ i ≤ k ; 1 ≤ j ≤ k ; i ≠ j}(¬ x_{a_{i}} < x_{a_{j}} ∧ ¬ x_{b_{i}} < x_{b_{j}}) ∧

nothing ; between ; A and B  ⋀_{{1 ≤ i ≤ k \atop 1 ≤ j ≤ l}} ¬∃z (x_{a_{i}} < z ∧ z < x_{b_{j}}) ∧

every node belongs to a trace  ∀z ⋁_{{1 ≤ i ≤ k \atop 1 ≤ j ≤ l}} (z < x_{a_{i}} ∨ z = x_{a_{i}} ∨ x_{b_{j}} < z ∨ x_{b_{j}} = z) ∧

φ_{A}|_{{x| ∨_{1≤i≤k} x≤x_{a_{i}} }} ∧ φ_{B}|_{{x| ∨_{1≤j≤l} x_{b_{j}} ≤x}})

• A^{c∗}, A^{cω} for a c-rational set A, where only connected parts are iterated: The logical definability of A^{c∗} was already claimed by Thomas [Tho90b]. We define φ_{A^{c∗}} and φ_{A^{cω}} as

∃X_{min}∃X_{max}

For every ; node x find ; borders of ; subtrace  ∀x ( ⋁_{{\{a_{1}, …, a_{k}\} \atop ⊆ Σ}} ⋁_{{\{b_{1}, …, b_{l}\} \atop ⊆ Σ}} ∃x_{a_{1}} … ∃x_{a_{k}}∃x_{b_{1}} … ∃x_{b_{l}}

(x_{a_{1}} ∈ X_{min} ∧ … ∧ x_{a_{k}} ∈ X_{min} ∧

x_{b_{1}} ∈ X_{max} ∧ … ∧ x_{b_{l}} ∈ X_{max} ∧

starting/ending nodes of the subtrace are incomparable and maximal such sets

“x_{a_{1}} … x_{a_{k}} are a maximal antichain in X_{min} (x_{a_{1}} … x_{a_{k}} are incomparable and there’s no node in X_{min}, that is incomparable to x_{a_{1}} … x_{a_{k}})” ∧ “x_{b_{1}} … x_{b_{l}} are a maximal antichain in X_{max}” ∧

subtrace around x well bounded

⋀_{1≤i≤k} x_{a_{i}} ≤ x ∧ ⋀_{1≤j≤l} x ≤ x_{b_{j}} ∧ ¬∃z

(((z < x ∧ ⋁_{1≤i≤k} x_{a_{i}} < z) ∨ (x < z ∧ ⋁_{1≤j≤l} z < x_{b_{j}})) ∧

(z ∈ X_{min} ∨ z ∈ X_{max})) ∧

Apply φ_{A} ; to subtrace  φ_{A}|_{≥{x_{a_{i}} },≤{x_{b_{j}} }})) ∧

∀x(“x minimal in the whole trace”) → x ∈ X_{min}) ∧

for A^{c∗}:  ∀x(“x maximal in the whole trace”) → x ∈ X_{max}) ∧

⋁_{1≤i≤|Σ|}(∃x_{1} … ∃x_{i} ∀x ⋁_{1≤j≤i} x ≤ x_{j})

for A^{cω}:  ∀x∃y x < y
□

4 Büchi Asynchronous Cellular Automata and equivalence to logic

Büchi asynchronous automata and Büchi asynchronous cellular automata were defined by Gastin and Petit [GP91]. These are generalizations of Büchi automata on infinite words and asynchronous (cellular) automata defined by Zielonka [Zie87]. The recognition power of Büchi asynchronous automata is equal to the recognition power of Büchi asynchronous cellular automata, like it is equal in the finite case for asynchronous automata and asynchronous cellular automata. In this paper we restrict ourselves to Büchi asynchronous cellular automata. The proofs are almost the same for Büchi asynchronous automata, and some details might be even easier.

Definition 4 A Büchi asynchronous cellular automaton A is a tuple A = ((Q_{a})_{a∈Σ}, (δ_{a})_{a∈Σ}, S, F, R) where Q_{a} is the local state set for process a, δ_{a} : ∏_{i∈D(A)}Q_{i} → P(Q_{a}) is the local transition function for process a,

S ⊆ ∏_{a∈Σ} Q_{a} is the set of starting states, F ⊆ ∏_{a∈Σ} Q_{a} is the set of accepting states for finite traces and R ⊆ ∏_{a∈Σ} P(Q_{a}) is the acceptance table for infinite traces.

In order to define runs of such an automaton we consider a trace t ∈ IR(Σ, D) as a labeled partial order (V, <, ℓ) with ℓ : V → A. A run r of A on t is a function r : V ∪ {v_{0}} → (⋃_{a∈Σ} Q_{a}) ∪ S, where v_{0} is an additional <-minimal node v_{0}, that is labeled with a starting state r(v_{0}) ∈ S, and for all v ∈ V:

r(v) ∈ δ_{ℓ(v)}((r(v_{max}^{i}))_{i∈D(ℓ(v))}),

where v_{max}^{i} is the <-maximal node labeled i before v. The set of locally repeated states is defined as

f_{a}(r) := { q ∈ Q_{a} | ∃^{ω}v : (ℓ(v) = a ∧ r(v) = q)
∨ ∃v(¬∃w(v < w ∧ ℓ(w) = a) ∧ r(v) = q) }. (1)
f(r) := ∏_{a∈Σ} f_{a}(r)  (2)

is the tuple of repeated states. The run r accepts t if f(r(t)) ⊇ R for some R ∈ R or if the maximal nodes of a finite run form a state in F. The accepted trace language of A is

T (A) = { t | there exists an accepting run r }.

Gastin and Petit [GP91] proved, that Büchi asynchronous cellular automata accept exactly the recognizable ω-trace languages. These languages are closed under intersection ∩, union ∪, complement and the concurrent star operation ^{c∗}.

Example 5 The dependence graphs of traces in the language T = (b^{∗}bac)^{∗}b^{ω} with the dependence alphabet D : a — b — c look similar to the following one.

[figure: b; b; a; c; b; b; b; a; c; b; b; b; …]

An automaton that accepts T is A = ((Q_{a})_{a∈Σ}, (δ_{a})_{a∈Σ}, S, F, R) with Q_{a} = {0, 1}, Q_{b} = {0, 1, 2}, Q_{c} = {0, 1}, and the transition function

δ_{a} : (0, 1) ↦ {1}  δ_{b} : (0, 0, 0) ↦ {1, 2}
(1, 0) ↦ {0}  (0, 1, 0) ↦ {1}
δ_{c} : (1, 0) ↦ {1}  (1, 1, 1) ↦ {0, 2}
(0, 1) ↦ {0}  (1, 0, 1) ↦ {0}
(0, 2, 0) ↦ {2}
(1, 2, 1) ↦ {2}

There are two possibilities to define the acceptance table: R = {({0}, {2}, {0}), ({1}, {2}, {1})} or R′ = {(∅, {2}, ∅)}. An example for a run is given below.

[figure: 1; 1; 1; 1; 0; 0; 0; 0; 0; 2; 2; 2; …; b; b; a; c; b; b; b; a; c; b; b; b; …; 0 0 0; global state (1, 1, 0)]
□

The equivalence of automata and logic is a consequence of the equivalence of recognizability and logic, since Büchi asynchronous cellular automata accept exactly the recognizable languages. In this section we will use the classical approach and provide an independent proof. We use standard techniques and some special constructions for Büchi asynchronous cellular automata. Since the case of finite traces has already been solved [Tho90b] we restrict ourselves to the case of infinite traces.

Theorem 6 A trace language T ⊆ IR(Σ, D) is accepted by some Büchi asynchronous cellular automaton if and only if T is definable in monadic second order logic.

Proof: “⇒”: Let A = ((Q_{a})_{a∈Σ}, (δ_{a})_{a∈Σ}, S, F = ∅, R) with Q_{a} = {0, …, m_{a}} be a Büchi asynchronous cellular automaton which accepts T. Every trace t is considered as a structure (V, <, ℓ). A computation r corresponds to a starting state s ∈ S and sets Y_{a0}, Y_{a1}, …, Y_{am_{a}} (for every a ∈ Σ), where Y_{ai} = { v ∈ V | ℓ(v) = a ∧ r(v) = i } contains all nodes that are labeled a and have the state i in the run r. The formula is given as follows.

existence of a computation ⋁_{s∈S} ∃Y_{a_{1}0} … ∃Y_{a_{1}m_{a_{1}}}

⋮
∃Y_{a_{n}0} … ∃Y_{a_{n}m_{an}}
every node gets at most one state  (“disjunct sets” ∧

labeling according to transition table

∀v ⋁_{{(p, a, q) \atop q ∈ δ_{a}(p)}} (P_{a}(v) ∧ v ∈ Y_{aq} ∧

find preceding state  ⋀_{b∈D(a)} (∃w (P_{b}(w) ∧ w < v ∧
¬∃u (w < u ∧ u < v ∧ P_{b}(u)) ∧
Y_{bπ_{b}(p)}(w)) ∨
or the starting state  (¬∃w (P_{a}(w) ∧ w < v) ∧
“π_{b}(s) = π_{b}(p)”))) ∧

choose an element of the acceptance table  ⋁_{R= ∏_{a∈Σ} R_{a}∈R} ⋀_{a∈Σ} ⋀_{{i=1 \atop R_{a}=\{q_{1},...,q_{l}\}}}^{l}

infinite repetition  (∃X(“X is infinite.” ∧ X ⊆ Y_{aq_{i}}) ∨
only finitely ; many a  ∃v v ∈ Y_{aq_{i}} ∧ ¬∃w (v < w ∧ P_{a}(w)))

“⇐”: Let φ be a second order formula that is in the restricted form of MSOL_{0} . Without loss of generality we have to consider predicates X ⊆ Y, X < Y, and X ⊆ P_{a}. We are going to perform induction over the construction of formulae. As there appear formulae with free variables in this induction we have to consider formulae φ(X_{1}, …, X_{n}) with free variables X_{1}, …, X_{n} over the dependence alphabet (Σ × {0, 1}^{n}, D_{n}) with

(a, ·) D_{n} (b, ·) iff a D b.

Induction foundation: We are working with formulae φ(X, Y) with two free variables X, Y. In this case we use an alphabet Σ×{0, 1}^{2}. The first additional digit indicates membership in X and the second additional digit indicates membership in Y. The generalization to arbitrary many free variables is easy. For all x ∈ Σ we consider processes x00, x01, x10, and x11. That gives a number of 4|Σ| processes.

• X ⊆ Y: This is a very simple automaton with only one global state 0^{4|Σ|} ∈ S. The processes x00, x01, and x11 continue and stay in the local state 0, if they read a node labeled x00, x01, and x11. These are nodes that are in Y if they are in X. The processes x10 stop, because they read nodes that are in X, but not in Y. The acceptance table is R = ({0}, …, {0}).

δ_{x00}(0^{D(x00)}) = {0}
δ_{x01}(0^{D(x00)}) = {0}
δ_{x11}(0^{D(x00)}) = {0}
δ_{x10}(0^{D(x00)}) = ∅  for all x ∈ Σ

• X < Y: Again we start out with the global starting state 0^{4|Σ|}. The local state 0 indicates a process not having any information. 1 indicates a process suggesting that it has read the first node in X, 2 means that there was a node in X somewhere, and 3 stands for reading a node in Y after there has been a node somewhere in X. Every process x00 remains in state 0, if all dependent states are still in state 0. Every process x10 waits until it is active and then changes its local state to 1, if all dependent processes are still in state 0. Now the automaton has read a node that is in X but not in Y. Every process x00 that sees a 1 or 2 in a dependent state and is still in state 0 changes its own state to 2. In doing this they spread the news that there has been a node in X. A process x01 that sees a 1 or 2 in a dependent state changes its own state to 3, to indicate that it has read a node in Y that is <-greater than the first node that was in X. R = { ∏_{a∈Σ} | |R_{a}| = 1 for all a ∈ Σ and exactly once R_{a} = {1} and exactly once R_{a} = {3} }.

δ_{x00}(0^{D(x00)}) = {0}
δ_{x00}( \underbrace{\{0, 1, 2\}^{D(x00)}}_{some 1 or 2, q_{x00} = 0}) = \{2\}

δ_{x10}(0^{D(x00)}) = {1}
δ_{x01}( \underbrace{\{0, 1, 2\}^{D(x00)}}_{some 1 or 2, q_{x01} = 0}) = \{3\}

δ_{x00}(\underbrace{\{0, 1, 2, 3\}^{D(x00)}}_{q_{x00} = q}) = \{q\} q ∈ \{1, 2, 3\}

• X ⊆ P_{a}: Now we have only one free variable and we start from 0^{2|Σ|} ∈ S. All processes x0 (for all x ∈ Σ) and the process a1 continue and stay in the local state 0. All other processes stop. The acceptance table is R = {{0}, …, {0}}.

δ_{x0}(0, …, 0) = {0} for all x ∈ Σ
δ_{a1}(0, …, 0) = {0}

Induction step:

• Closure under conjunction ∧ and disjunction ∨: Cartesian product of automata [GP91].

• Closure under complement ¬: Büchi asynchronous automata recognize exactly the recognizable languages [GP91] and these are closed under complement.

• Closure under quantification (projection) of variables ∃ (∀ may be expressed by ¬ and ∃): The automaton for a formula ∃Xφ(X) (we can easily add more free variables, that are not quantified in this step) over the alphabet Σ × {0, 1} is built taking the automaton for φ(X). We melt every pair of processes x0, x1. The new process x has state set Q_{x} = Q_{x0} × Q_{x1} and guesses nondeterministically whether a node is in X or not and then performs a transition either in the component Q_{x0} or in the component Q_{x1}. □

If we had a construction of a complement automaton, our proof would be completely constructive. A complementation construction similar to the standard complementation construction for Büchi automata does work. But we are looking for a more constructive complementation.

5 Star-free ω-trace languages and first order logic

In the case of finite traces [GRS91], finite words, and ω-words [Tho90a, for an overview] star-free languages are exactly the first order definable ones. In order to investigate star-free ω-trace languages we first have to give a definition of star-free ω-trace languages. One possibility is to use star-free expressions with only boolean operations and concatenation, where the complement can be taken with respect to A^{∗} in order to get star-free sets of finite traces and with respect to A^{∗} and A^{ω} in order to get star-free sets of infinite traces. We can perform a part of the proof of the equivalence of recognizability and logic in the case of star-free languages and first order logic:

⋃ T is definable

⟹^{(1′)} in FO[<]

Ladner, Thomas

⟺

T is  ⋃ T is
definable  star-
in FO[<]  free
⟸^{(2′)}  T is  ⟸^{(3′)}

star-free

For the implication (1′) we have to express the <-relation on the traces directly by a first order formula using the <-relation on the words: x < y in the partial order on the traces if and only if

⋁_{(a_{1},a_{2})∈D ; (a_{2},a_{3})∈D ; ⋮ ; (a_{l−1},a_{l})∈D ; {a_{1},...,a_{l}}⊆A ; |{a_{2},...,a_{l}}|=l−1} ∃x_{2} … ∃x_{l−1}(Q_{a_{1}}(x) ∧ Q_{a_{2}}(x_{2}) ∧ …

… ∧ Q_{a_{l−1}}(x_{l−1}) ∧ Q_{a_{l}}(y) ∧ x < x_{2} < … < x_{l−1} < y)

For the implication (2′) we replace the boolean operations by the corresponding logical operations. For concatenation we can use the first order formula that we gave in the proof of equivalence of logic and recognizability. The remaining direction (3′) will be shown in a forthcoming joint work with V. Diekert and A. Muscholl.

Acknowledgements

The author wants to thank Volker Diekert, Paul Gastin, Hendrik Jan Hoogeboom, Anca Muscholl, Antoine Petit, and Wolfgang Thomas for many helpful discussions, corrections, and suggestions.

References

[Die90] V. Diekert. Combinatorics on Traces. Number 454 in Lecture Notes in Computer Science. Springer, Berlin-Heidelberg-New York, 1990.

[Die91] V. Diekert. On the concatenation of infinite traces. In Choffrut C. et al., editors, Proceedings of the 8th Annual Symposium on Theoretical Aspects of Computer Science (STACS’91), Hamburg 1991, number 480 in Lecture Notes in Computer Science, pages 105–117. Springer, Berlin-Heidelberg-New York, 1991.

[Gas91] P. Gastin. Recognizable and rational trace languages of finite and infinite traces. In Choffrut C. et al., editors, Proceedings of the 8th Annual Symposium on Theoretical Aspects of Computer Science (STACS’91), Hamburg 1991, number 480 in Lecture Notes in Computer Science, pages 89–104. Springer, Berlin-Heidelberg-New York, 1991.

[GP91] Paul Gastin and Antoine Petit. Asynchronous automata for infinite traces. Rapport de Recherche 707, Université de Paris-Sud, 1991. To appear in ICALP 1992, also this volume, pages 29–45.

[GPZ91] P. Gastin, A. Petit, and W. Zielonka. A Kleene theorem for infinite trace languages. In J. Leach Albert et al., editors, Proceedings of the 18th International Colloquium on Automata Languages and Programming (ICALP’91), Madrid (Spain) 1991, number 510 in Lecture Notes in Computer Science, pages 254–266. Springer, Berlin-Heidelberg-New York, 1991.

[GRS91] Giovanna Guaiana, Antonio Restivo, and Sergio Salemi. On aperiodic trace languages. In Choffrut C. et al., editors, Proceedings of the 8th Annual Symposium on Theoretical Aspects of Computer Science (STACS’91), Hamburg 1991, number 480 in Lecture Notes in Computer Science, pages 76–88. Springer, Berlin-Heidelberg-New York, 1991.

[Maz77] A. Mazurkiewicz. Concurrent program schemes and their interpretations. DAIMI Rep. PB 78, Aarhus University, Aarhus, 1977.

[Och85] E. Ochmanski. Regular behaviour of concurrent systems. Bulletin of the European Association for Theoretical Computer Science (EATCS), 27:56–67, Oct 1985.

[Tho90a] Wolfgang Thomas. Automata on infinite objects. In Jan van Leeuwen, editor, Handbook of Theoretical Computer Science, chapter 4, pages 133–191. Elsevier Science Publishers B. V., 1990.

[Tho90b] Wolfgang Thomas. On logical definability of trace languages. In V. Diekert, editor, Proceedings of a workshop of the ES-PRIT 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.

[Zie87] W. Zielonka. Notes on finite asynchronous automata. R.A.I.R.O.-Informatique Théorique et Applications, 21:99– 135, 1987.

123 124 M. Kwiatowska, M. Stannett On transfinite traces 125 126 M. Kwiatowska, M. Stannett On transfinite traces 127 128 M. Kwiatowska, M. Stannett On transfinite traces 129 130 M. Kwiatowska, M. Stannett On transfinite traces 131 132 M. Kwiatowska, M. Stannett On transfinite traces 133 134 M. Kwiatowska, M. Stannett On transfinite traces 135 136 M. Kwiatowska, M. Stannett On transfinite traces 137 138 M. Kwiatowska, M. Stannett On transfinite traces 139 140 M. Kwiatowska, M. Stannett On transfinite traces 141 142 M. Kwiatowska, M. Stannett On transfinite traces 143 144 M. Kwiatowska, M. Stannett On transfinite traces 145 146 M. Kwiatowska, M. Stannett On transfinite traces 147 148 M. Kwiatowska, M. Stannett On transfinite traces 149 150 M. Kwiatowska, M. Stannett On transfinite traces 151 152 M. Kwiatowska, M. Stannett On transfinite traces 153 154 M. Kwiatowska, M. Stannett On transfinite traces 155 156 M. Kwiatowska, M. Stannett On transfinite traces 157

On Temporal Logics for Trace Systems

Wojciech Penczek^{∗}

Institute of Computer Science, Polish Academy of Sciences 00-901 Warsaw, PKiN, P.O. Box 22, Poland

March 1992

Abstract

We investigate an extension of CTL (Computation Tree Logic) by past modalities, called CTL_{P}, interpreted over Mazurkiewicz’s trace systems. The logic is powerfull enough to express most of the partial order properties of distributed systems like serializability of database transactions, snapshots, parallel execution of program segments, or inevitability under concurrency fairness assumption. We show that a model checking problem for the logic is NP-hard, even if past modalities cannot be nested. Then, we give a one exponential time model checking algorithm for the logic without nested past modalities. We show that all the interesting partial order properties can be model checked using our algorithm. Then, we show that it is possible to extend the model checking algorithm to cover the whole language and its extension to CTL*_{P}. At the end, we prove that the logic is undecidable and we discuss consequences of our results on using propositional versions of partial order temporal logics to synthesis of concurrent systems from their specifications.

Keywords: Concurrency; Trace Systems; Partial Order Temporal Logics; Automated Verification.

∗This research has been partly supported by the Netherlands grant NWO NF 3/62 - 500 and a grant from The Wolfson Research Awards Scheme in The United Kingdom.

1 Introduction

Linear time [1] and branching time [2] temporal logics are usually applied for specifying and proving properties of concurrent systems and programs. Lately, several attempts have been made to use also logics interpreted over partial order structures [3 - 14]. The main motivation for defining these logics was to express properties inherent in the partial order interpretations, more specifically to distinguish concurrency from non-determinism.

There are two approaches to extend linear and branching time temporal logics to partial order logics on global states. Either run modalities are introduced (see QISTL [5], ISTL [5,6], CCTL [9,15], Petri Net Logics [11,12]), or past operators over partial order semantics are defined (see POL [14], PN-logics [11,12], and [13, 16]). Temporal logics over partial order semantics allow for expressing properties not expressible in logics over interleaving semantics. These properties are: inevitability under concurrency fairness assumption [17,18], serializability of database transactions [13, 16], causal successor [11, 12, 14], or the parallel execution of program segments [13, 14].

Model checking is one of the main methods of automated verification of concurrent systems [38]. It has been intensively studied for linear-time temporal logics [19, 20], branching-time temporal logics [21 - 26], and modal μ-calculi [25,27]. Model checking has been also applied to prove properties of systems, represented by partial orders of local states [3, 4]. Methods for making it applicable to very large systems and of avoiding the state explosion problem have been proposed in [28 - 31].

As far no one has tried to investigate whether and how logics with partial order past operators, interpreted over global state models, can be used for automated verification of concurrent systems. Since Hennessy and Stirling [32] introduced backward modalities to program logics, all the work has concentrated around the induced equivalences [33,34], expressiveness issues [11,12,14,32,33], and proof systems [13,16]. In this paper we fill this gap. Moreover, our results explain why it is so difficult to deal with partial order logics, what is a common observation.

We start with defining a logic CTL_{P}, which is a simple extension of CTL by past modalities. In fact, the language of CTL_{P} is a restriction of that, considered in [3,4,13,16], and it is an extension of the language of Hennessy-Milner logic with past modalities [32]. Our choice is motivated by the following observations. CTL has proved to be a very usefull logic for automated verification. Model checking for CTL is linear in the size of a model and linear in the lenght of the formula [21], and the complexity of checking satisfiability is deterministic exponential in the size of a tested formula [35], whereas the complexity of model checking for CTL* is PSPACE-complete [22], and checking satisfiability is deterministic double exponential [36]. It turned out that it is possible to extend CTL to fair CTL (FCTL) [24] or to model check CTL formulas over fair paths [26] without changing the complexity of CTL model checking. Moreover, different methods dealing with the state explosion problem have been given [28,29].

We would be quite happy with these results, if the logic could distinguish concurrency from non-determinism and consequently, properties of partial order executions could be expressed. Unfortunately, this is not the case. Therefore, it seems very natural to consider a minimal extension of CTL s.t. properties of partial orders can be specified and proved. This can be done by introducing past modalities to the language. Then, our logic has to be interpreted over partial order models rather than over trees. Again, we select the simplest and the most frequently used partial order structures of global states, namely, Mazurkiewicz’s trace systems (see [13,17,18,37,46]). In this paper we investigate consequences of our extension. Firstly, we show that for proving all the interesting partial order properties for finite state systems we can restrict ourselves to a model checking algorithm for the language without nested past modalities, call it CTL_{P −}. Then, we prove that model checking for CTL_{P −} is NP-hard. Consequently, we give a one exponential time model checking algorithm for this restricted language and show how it can be extended (if ever needed) to cover the whole logic. Our model checking algorithm requires a new technique, not applied before to model checking for CTL or CTL*. Secondly, we turn to the problem of determining satisfiability for CTL_{P} formulas. To our surprise, we show that even CTL_{P −} is not decidable. Since this result can be extended as well on other partial order temporal logics, interpreted over trace systems, like ISTL [13], or the logic, defined in [16], therefore we show an important limitation in applying partial order logics to synthesis of concurrent systems from their specifications.

The rest of this paper is organized as follows. In section 2 trace systems are introduced. EN - systems and trace semantics is defined in section 3. Then, in section 4 the logic CTL_{P} and its semantics is presented. Acceptors for finite state trace systems and model generators are defined in section 5. Section 6 contains the proof of NP-hardness of CTL_{P} model checking and section 7 shows a model checking algorithm for CTL_{P −} and its possible extensions. Undecidability of CTL_{P} is proved in section 8 and then, in section 9, CTL_{P} is compared with other temporal logics. Final remarks are given in section 10.

2 Trace Systems

We start with introducing notions of traces and trace systems from [17].

By an independence alphabet we mean any ordered pair (Σ, I), where Σ is a finite set of symbols (action names) and I ⊆ Σ × Σ is a symmetric and irreflexive binary relation in Σ (the independence relation). Let (Σ, I) be an independence alphabet. Define ≡ as the least congruence in the (standard) string monoid (Σ^{∗}, ∘, ϵ) such that (a, b) ∈ I ⇒ ab ≡ ba, for all a, b ∈ Σ i.e., w ≡ w′, if there is a finite sequence of strings w_{1}, …, w_{n} s.t. w_{1} = w, w_{n} = w′, and for each i < n, w_{i} = uabv, w_{i+1} = ubav, for some (a, b) ∈ I and u, v ∈ Σ^{∗}. Equivalence classes of ≡ are called traces over (Σ, I). The trace generated by a string w is denoted by [w]. We use the following notations:

• [Σ^{∗}] = {[w] | w ∈ Σ^{∗}}, [Σ^{+}] = {[w] | w ∈ Σ^{+}}, and [Σ] = {[a] | a ∈ Σ}.

Concatenation of traces [w], [v], denoted [w][v], is defined as [wv]. For more deatails about traces see [17].

Now, let T be the set of all traces over (Σ, I). The successor relation → in T is defined as follows: [w_{1}] → [w_{2}] iff there is a ∈ Σ such that [w_{1}][a] = [w_{2}]. The prefix relation ≤ in T is defined as a reflexive and transitive closure of the successor relation i.e., ≤ = (→)^{∗}. By < we mean ≤ − id_{T}. Let τ ∈ T and Q ⊆ T. We use the following notations:

• ↓ τ = {τ′ ∈ T | τ′ ≤ τ}, ↑ τ = {τ′ ∈ T | τ ≤ τ′},

• ↓ Q = ⋃_{τ∈Q}{τ′ ∈ T | τ′ ≤ τ}, ↑ Q = ⋃_{τ∈Q}{τ′ ∈ T | τ ≤ τ′}.

We say that a subset Q of T dominates another subset R of T, if R ⊆ ↓ Q. Two traces are consistent, if there is a trace in T dominating both of them and inconsistent otherwise. A set R of traces is said to be proper, if any two of its consistent traces are dominated by a trace in R, and directed, if arbitrary two traces in R are dominated by a trace in R. A set of traces Q is said to be prefix-closed, if Q = ↓ Q.

By a trace system T over (Σ, I) we mean any prefix-closed and proper trace language over (Σ, I); traces T r(T ) in a trace system T is called states of T .

A trace together with its prefixes represents a partial execution of the system. Maximal (w.r.t. the inclusion ordering) directed subsets R of T r(T ) is called runs of T . A run represents a single maximal execution of the system T . By a path in R ⊆ T r(T ) we mean a maximal sequence x = τ_{0}a_{0}τ_{1}a_{1} … in R such that τ_{i}[a_{i}] = τ_{i+1} for all i ≥ 0. For convenience, we write also x = τ_{0}τ_{1} . . .. Let ↓ x = {τ ∈ T r(T ) | τ ≤ τ_{i}, for i ≥ 0} be a set of traces dominated by a path x. By an observation of a run R in T we mean any path x in R such that R = ↓ x; we say also that x is an observation (of T ). Notice that an observation is such a path that is cofinal with some run. Thus, it carries the information about all actions executed in the run. A suffix τ_{i}a_{i}τ_{i+1}a_{i+1} … of an observation x is said to be an observation starting at τ_{i}.

Lemma 2.1 A path x = τ_{0}a_{0}τ_{1}a_{1} … in T r(T ) is an observation iff

(∀a ∈ Σ)(∀i ∈ IN)(∃j ≥ i)(τ_{j}[a] ∉ T r(T ) or (a, a_{j}) ∉ I).

Proof can be found in [13] or in [39].

Obviously, the above lemma holds for suffixes of observations. The comparison between the notion of an observation and the notion of a juste computation can be found in [18]. In fact, each juste path is an observation, but not the other way round.

A subset Q ⊆ T r(T ) is said to be inevitable, if each observation of T contains a state in Q. Inevitability is an important property for trace systems, discussed in [17,18].

Since one of the aims of this paper is to show a method of proving properties of trace systems by model checking, the finitely representable trace systems are of interest. They are called finite state trace systems.

Definition 2.1 A trace system T is said to be finite state, if there is an equivalence relation EQ ⊆ T r(T ) × T r(T ) in the set of traces of T satisfying the following two conditions:

1. EQ has a finite index,

2. (∀τ, τ′ ∈ T r(T ))(∀α ∈ [Σ]) ((τ EQ τ′ and τα ∈ T r(T )) ⇒ (τα EQ τ′α)).

The above definition says that T contains a finite number of traces “distinguishable w.r.t. their continuations in T ”. It should be noticed that T may have infinitely many traces with different histories i.e., ↓ τ ≠↓ τ′, for infinitely many τ, τ′ ∈ T r(T ).

Examples of trace systems and of accompanying notions are given in the next section. Trace systems are commonly used for giving semantics to Elementary Net Systems [17] and finite state programs. In [13] trace systems were used for giving semantics to a wider class of concurrent programs, namely those for which equivalence classes are associated with first order interpretations. Below, EN-systems are defined and it is shown how to define their trace semantics. EN-systems serve us as examples of finite state concurrent systems.

3 EN-systems and trace semantics

Now, a subclass of Petri Nets, called EN-systems, is introduced.

Definition 3.1 (EN-system) A EN-system is an ordered quadruple N = (B, E, F, c_{0}), where B and E are finite, disjoint, nonempty sets of places and transitions, resp., F ⊆ B × E ∪ E × B is the flow relation, with dom(F) ∪ dom(F) = B ∪ E, and c_{0} ⊆ B is the initial case.

Any subset c of B is called a case. Nets are illustrated graphically using lines for representing transitions, circles for places, and arrows for the flow relation.

Definition 3.2 Let N be a EN-system. For each x ∈ B ∪ E, the following sets are defined:

• P re(x) = {y | (y, x) ∈ F },

• P ost(x) = {y | (x, y) ∈ F },

• P rox(x) = P re(x) ∪ P ost(x).

Definition 3.3 (firing sequence) We say that a transition t is fireable at a case c and leads to the case c′ (written c[t> c′), if P re(t) ⊆ c, P ost(t) ⊆ c′, and c − P re(t) = c′ − P ost(t).

A finite sequence of transitions w = t_{0}t_{1} … t_{n} is said to be a firing sequence of N, if there is a sequence of cases c_{1}, …, c_{n+1} s.t. c_{i}[t_{i} > c_{i+1}, for i ≤ n. This is denoted by c_{0}[w > c_{i+1}. The case c_{n+1} is said to be reachable.

Definition 3.4 A EN-system N is said to be contact-free iff for each reachable case c and for all t ∈ E, the following condition holds:

• P re(t) ⊆ c implies P ost(t) ∩ (c − P re(t)) = ∅.

Therefore, for contact-free nets a transiton t is fireable at c, if P re(t) ⊆ c. All the EN-systems, used in the examples in the paper, are contact-free.

Next, it is shown how trace systems give semantics to EN-systems.

Definition 3.5 (trace semantics) The trace system T over (Σ, I) represents behaviour of a EN-system N = (B, E, F, c_{0}), if the following conditions hold:

• Σ = E,

• (a, b) ∈ I iff P rox(a) ∩ P rox(b) = ∅, and

• T r(T ) = {[w] ∈ [Σ^{∗}] | w is a firing sequence of transitions in N}.

Example 3.1 Notice that trace systems giving a semantics to ENsystems are finite state. Let N = (B, E, F, c_{0}) be a EN-system and T be the trace system representing behaviour of N. T is finite-state and EQ can be defined as follows:

(∀[w], [w′] ∈ T r(T ))(∀c ⊆ B) [w] EQ [w′] iff (c_{0}[w > c ⇔ c_{0}[w′ > c).

To allow the comparison of the approach presented here with that of Peled and Pnueli, all the examples shown below are taken from their paper [13].

Example 3.2 (inevitability) Below, EN-system N_{1} together with its trace system semantics T_{1} is presented.

[figure: 2; 1; 4; 5; 3; a; b; c; d; Figure 1: EN-system N_{1}]
The EN-system N_{1} = (B_{1}, E_{1}, F_{1}, c_{0}^{1}), where

166 W. Penczek

• B_{1} = {1, 2, 3, 4, 5},

• E_{1} = {a, b, c, d},

• F_{1} = {(1, a), (a, 2), (1, b), (b, 4), (3, b), (3, c), (c, 5), (5, d), (d, 3)},

• c_{0}^{1} = {1, 3}.

[figure: [a]; [ac]; [cda]; [cdca]; [ϵ]; [c]; [cd]; [cdc]; [b]; [cdb]; Figure 2: Trace Semantics T_{1} of System N_{1}]

The independence alphabet (Σ, I) is defined as follows:

• Σ = {a, b, c, d},

• I = {(a, c), (c, a), (a, d), (d, a)}. There are infinitely many finite runs R_{i} and one infinite run R in the trace system T_{1}:

• R_{i} =↓ [(cd)^{i}b], for i ≥ 0,

• R = ⋃_{i=1}^{∞} ↓ [(cd)^{i}a] Every path in T r(T_{1}) except for x = [ϵ][c][cd][cdc]... is an observation of T_{1}. The following is an example of an inevitability property:

• INEVITABILITY: Either a or b will be eventually executed. (i.e., cases containing 2 or 4 will be reached inevitably).

One could be estonished that either a or b is inevitable as there is an infinite path x = [ϵ][c][cd][cdc] … in which neither a nor b is executed. But this path is not an observation and according to the definition, a property is inevitable if it holds for each observation.

Example 3.3 (serializability) Below, EN-system N_{2} and its trace semantics is presented. Then, an example of a serializability property is given.

[figure: 9; 7; 8; a_{3}; b_{3}; 5; 6; a_{2}; b_{2}; 3; 4; a_{1}; b_{1}; 1; 2; Figure 3: EN-system N_{2}]

[figure: [a_{1}a_{2}a_{3}b_{1}b_{2}b_{3}]; [b_{1}b_{2}b_{3}a_{1}a_{2}a_{3}]; [a_{1}a_{2}a_{3}b_{1}b_{2}]; [b_{1}b_{2}b_{3}a_{1}a_{2}]; [a_{1}a_{2}a_{3}b_{1}]; [b_{1}b_{2}b_{3}a_{1}]; [a_{1}a_{2}a_{3}]; [a_{1}a_{2}b_{1}]; [b_{1}b_{2}a_{1}]; [b_{1}b_{2}b_{3}]; [a_{1}a_{2}]; [a_{1}b_{1}]; [b_{1}b_{2}]; [ a_{1} ]; [ b_{1} ]; [ ϵ ]; Figure 4: Trace Semantics T_{2} of N_{2}]

The EN-system N_{2} = (B_{2}, E_{2}, F_{2}, c_{0}^{2}) is defined as follows:

• B_{2} = {1, 2, 3, 4, 5, 6, 7, 8, 9},

• E_{2} = {a_{1}, a_{2}, a_{2}, b_{1}, b_{2}, b_{3}},

• F_{2} = {(1, a_{1}), (a_{1}, 3), (3, a_{2}), (a_{2}, 5), (5, a_{3}), (a_{3}, 7), (a_{3}, 9), (9, a_{2}), (9, b_{2}), (2, b_{1}), (b_{1}, 4), (4, b_{2}), (b_{2}, 6), (6, b_{3}), (b_{3}, 9), (b_{3}, 8)},

• c_{0}^{2} = {1, 2, 9}.

The trace system T_{2} contains two runs, marked by the thin and the thick lines.

• SERIALIZABILITY:

The net N_{2} can be thought of as implementing a database with two transactions T_{1} = {a_{1}, a_{2}, a_{3}} and T_{2} = {b_{1}, b_{2}, b_{3}}. Each transition can represent database read or write operation. An implementation is correct, if transactions are serializable. Serializability of T_{1} and T_{2} [13] in terms of trace semantics is as follows: In every run, there exists an observation in which either all the operations of T_{1} appear before those of T_{2}, or the other way round, i.e., there is an observation, which behaves in a serial manner. One can check that indeed in each run there is an observation satisfying the above requirement, namely:

• [ϵ][a_{1}][a_{1}a_{2}][a_{1}a_{2}a_{3}][a_{1}a_{2}a_{3}b_{1}][a_{1}a_{2}a_{3}b_{1}b_{2}][a_{1}a_{2}a_{3}b_{1}b_{2}b_{3}] in the “thick” line marked run, and

• [ϵ][b_{1}][b_{1}b_{2}][b_{1}b_{2}b_{3}][b_{1}b_{2}b_{3}a_{1}][b_{1}b_{2}b_{3}a_{1}a_{2}][b_{1}b_{2}b_{3}a_{1}a_{2}a_{3}] in the “thin” line marked run.

In the next part of the paper it is shown how to express the mentioned properties in the logic and then how to prove them by model checking.

4 Logic CTL_{P} and its semantics

Next, the language of CTL_{P} is defined and then semantics is presented.

4.1 Syntax of CTL_{P}

Let Σ be a fixed set of action names. Now, we define the set of state and path formulas of CTL_{P}.

Let P V be a set of propositional variables.

1. Each p ∈ P V is a state formula, 2. if φ and ψ are state formulas, then so are φ ∧ ψ, ¬φ,

3. if φ is a state formula, then so are Y_{a}φ (for a ∈ Σ), and Hφ,

4. if φ is a state formula, then X_{a}φ (for a ∈ Σ), Gφ, and φUψ are path formulas,

5. if φ is a path formula, then Eφ is a state formula.

The symbol E can be called an observation quantifier (it corresponds to path quantifiers in CTL). The other symbols have the following intuitive meaning: X_{a} - next step ”along” a, U - Until, G - always in the future, Y_{a} - backward step ”along” a, H - always in the past. Path formulas are interpreted over observations and state formulas are evaluated at states of models. Formulas of the form Y_{a}φ, Hφ are called past formulas.

The following abbreviations are used:

• φ ∨ ψ =^{def} ¬(¬φ ∧ ¬ψ),

• true =^{def} φ ∨ ¬φ, for any φ,

• φ ⇒ ψ =^{def} ¬φ ∨ ψ,

• F φ =^{def} trueUφ,

• P φ =^{def} ¬H¬φ,

• EXφ =^{def} ⋁_{a∈Σ} EX_{a}φ, AXφ =^{def} ¬EX¬φ,

• Y φ =^{def} ⋁_{a∈Σ} Y_{a}φ,

• AGφ =^{def} ¬EF ¬φ,

• A(φUψ) =^{def} ¬(E(¬ψU(¬φ ∧ ¬ψ)) ∨ EG(¬ψ)).

The lack of symmetry between backward and forward operators stems from the fact that the past of a state is conflict-free whereas the future may not.

In this paper we also consider a logic CTL_{P −}, which is a restriction of CTL_{P} s.t. past formulas cannot be nested.

On temporal logics on trace systems 171

4.2 Semantics of CTL_{P}

Now, we define formally the semantics of CTL_{P}. Definition 4.1 A frame (for a trace system T over (Σ, I)) is a triple F_{v_{0}} = (W, →, v_{0}), where W = T r(T ) is the set of traces of the trace system T , →⊆ W × Σ × W is a labelled transition relation s.t. τ →^{a} τ′ iff τ′ = τ[a], and v_{0} = [ϵ]. Definition 4.2 A model (for a trace system T over (Σ, I)) is an ordered pair M = (F_{v_{0}}, V), where F_{v_{0}} = (W, →, v_{0}) is a frame for T and V : W ⟶ 2^{P V} is a valuation function. The notion of truth in M is defined by the relation ⊧ as follows:

1. M, w_{0} ⊧ p iff p ∈ V (w_{0}), for p ∈ P V,

2. if φ, ψ are state formulas, M, w_{0} ⊧ ¬φ iff not M, w_{0} ⊧ φ, M, w_{0} ⊧ φ ∧ ψ iff M, w_{0} ⊧ φ and M, w_{0} ⊧ ψ,

3. M, w_{0} ⊧ Hφ iff M, w′ ⊧ φ, for all w′ : w′ < w_{0},

M, w_{0} ⊧ Y_{a}φ iff M, w′ ⊧ φ, for some w′ : w′ →^{a} w_{0},

4. if x = w_{0}a_{0}w_{1}a_{1} … is an observation starting at w_{0}, then M, x ⊧ X_{a}φ iff M, w_{1} ⊧ φ and a_{0} = a, M, x ⊧ Gφ iff M, w_{i} ⊧ φ for all i ≥ 0, M, x ⊧ φUψ iff there is k ≥ 0 s.t. M, w_{k} ⊧ ψ, and for all 0 ≤ i < k: M, w_{i} ⊧ φ,

5. if φ is a path formula, then M, w_{0} ⊧ Eφ iff M, x ⊧ φ, for some observation x starting at w_{0}.

We say that a formula φ is valid in a model M (written M ⊧ φ), if M, v_{0} ⊧ φ. Such notion of validity in model is sometimes called the anchored validity. A formula φ is said to be valid, if M ⊧ φ, for all models M.

The language of CTL_{P} contains all the CTL formulas (with slightly different semantics, tuned to observations) and moreover the formulas with the past modalities H and Y_{a}.

Since our logic needs to be able to speak about actions, we have defined labelled next and backward step operators. However, we have done that only for simplicity. To show that we could have avoided introducing labelled operators we give the following example of a valuation function, which encodes labels of transitions. Then, labelled operators are expressible using their unlabelled versions.

Example 4.1 Let P V_{Σ} = {p_{a} | a ∈ Σ} ⊆ P V and let V satisfy the following condition:

• p_{a} ∈ V (τ) iff ♯_{a}(τ) is odd, (♯_{a}(τ) is the number of occurrences of a in τ).

Then, EX_{a}φ would be equivalent to a formula (p_{a} ⇒ EX(¬p_{a} ∧ φ)) ∧ (¬p_{a} ⇒ EX(p_{a} ∧ φ)) and Y_{a}φ would be equivalent to a formula (p_{a} ⇒ Y (¬p_{a} ∧ φ)) ∧ (¬p_{a} ⇒ Y (p_{a} ∧ φ)).

4.3 Expressiveness of CTL_{P}

We give several examples of expressiveness of CTL_{P}. Then, we convince the reader that for finite state models, if we can express properties of partial executions and runs, then we can specify serializability. Let M = (F_{v_{0}}, V) be a model for a trace system T .

• M, v_{0} ⊧ AGφ – φ is an invariant in T ,

• M, v_{0} ⊧ AF φ – φ is inevitable in T , (under a concurrency fairness assumption),

• M, v_{0} ⊧ EF φ – φ is possible in T , • M, v_{0} ⊧ EF (Hφ ∧ φ) – there is a partial execution in T s.t. φ

holds at all its states,

• M, v_{0} ⊧ EG(Hφ ∧ φ) – there is a run in T s.t. φ holds at all its states,

• M, v_{0} ⊧ AF (P φ ∨ φ) – φ holds at some state of each run in T ,

• M, v_{0} ⊧ EF (Y_{a}(true)∧Y_{b}(true)) – actions a and b are independent in T ,

• M, v_{0} ⊧ AG(φ ⇒ P ψ) – always if φ holds, ψ held in the past; this formula allows for specifying snapshots of concurrent programs [13, 16], (φ and ψ do not contain temporal formulas).

Assume now that the trace system T is finite state and given an equivalence relation EQ in T r(T ) s.t. |EQ| = n. Moreover, we require that a valuation function of equivalent states is the same i.e., V (τ) = V (τ′), if τ EQ τ′. Now, we show how serializability of two transactions T_{1} and T_{2} can be specified.

Obviously, we consider here a simplified version of serializability without taking into account aborts and any consistency conditions of specific operations of transactions. All these requirements could be also specified by translating first order formulas, defined in [16], into their propositional versions. Here, we concentrate our attention on specifying that transactions can be serialized.

Let M = (F_{v_{0}}, V) be a model for T . Firstly, assume that transactions are executed only once. Denote by before_{i} and after_{i} the assertions meaning that control is before or after the execution of transaction T_{i}, respectively. Then, serializability of T_{1} and T_{2} can be expressed as follows:

1. (before_{1} ∧ before_{2}) ⇒ AF P ((before_{1} ∧ after_{2}) ∨ (before_{2} ∧ after_{1})),

2. AG(((before_{1} ∧ after_{2}) ∨ (before_{2} ∧ after_{1})) ⇒ AF (P (after_{1} ∧ after_{2}) ∨ (after_{1} ∧ after_{2}))).

The first formula expresses that each run contains a state at which either control is before the execution of T_{1} and after the execution of T_{2}, or the other way round. The second formula says that each run contains a state at which control is after the execution of T_{1} and T_{2}.

Secondly, we assume that T_{1} and T_{2} are executed infinitely many times. We denote by ”quiescent_{i}” and “active_{i}” the assertions meaning that a transaction T_{i} has already terminated or has not yet started, and that T_{i} is active, respectively. Moreover, we assume that we have a set of assertions {θ_{1}, …, θ_{n}}, identyfing uniquely states belonging to different equivalence classes of EQ i.e., at each state exactly one θ_{i} holds and at states belonging to the same equivalence class the same θ_{j} holds. Then, serializability of T_{1} and T_{2} can be expressed as follows:

SER1: AG[⋀_{j=1}^{n}((θ_{j} ∧ ⋀_{i=1}^{2} quiescent_{i}) ⇒ AF (⋀_{i=1}^{2} P (active_{i} ∧ P (θ_{j})))]

SER2: AG[(⋀_{j=1}^{n}((θ_{j} ∧ ⋁_{i=1}^{2} active_{i}) ⇒ AF P ((⋀_{i=1}^{2} quiescent_{i} ∧ P (θ_{j})))]

SER3: AG[⋀_{j=1}^{n}((θ_{j} ∧ ⋀_{i=1}^{2} quiescent_{i}) ⇒

AG((⋀_{i=1}^{2}(quiescent_{i} ∧P (active_{i} ∧P (θ_{j}))) ⇒ P (⋀_{i=1}^{2} quiescent_{i} ∧

P (θ_{j}))))]

The formula SER1 expresses that if at some state s transactions T_{1} and T_{2} are quiescent, then for each run in the future of s transactions T_{1} and T_{2} will become active. The formula P (θ_{j}) is used in order to guarantee that the transactions become active in the future of s. The formula SER2 says that if at some state s the transactions T_{1} and T_{2} are active, then for each run at some state in the future of s the transactions T_{1} and T_{2} will become quiescent. We have to add also the third formula. Informally saying, the formula SER3 expresses that for each trace ”starting” and ”ending” at a state, where T_{1} and T_{2} are quiescent, but were active at some its prefix, there is a linearisation, which behaves in a serial manner.

Example 4.2 Now, it is shown how the properties, we have discussed in the former examples, can be formally expressed by CTL_{P} formulas. Firstly, models are defined. Let P V_{i} = {p_{b} | b ∈ B_{i}}, where B_{i} is the set of places of EN-system N_{i}, for i ∈ {1, 2}. The valuation function assigns to each state these propositions which correspond to marked places.

The model M_{1} = (F_{[ϵ]}^{1}, V_{1}), for the trace system T_{1} is defined as follows:

• F_{[ϵ]}^{1} = (W_{1}, →_{1}, [ϵ]) is the frame for T_{1},

• V_{1} : W_{1} ⟶ 2^{P V_{1}} s.t.

– p_{b} ∈ V_{1}([w]) iff p_{b} ∈ c, for the case c s.t. c_{0}^{1}[w > c in N_{1}.

In the following way, the property, discussed in Example 3.2, can be expressed by CTL_{P} formulas:

• INEVITABILITY: p_{1} ∧ p_{3} ⇒ AF (p_{2} ∨ p_{4}),

The model M_{2} = (F_{[ϵ]}^{2}, V_{2}) for the trace system T_{2} is defined as follows:

• F_{[ϵ]}^{2} = (W_{2}, →_{2}, [ϵ]) is the frame for T_{2},

• V_{2} : W_{2} ⟶ 2^{P V_{2}} s.t.

– p_{b} ∈ V_{2}([w]) iff b ∈ c, for the case c s.t. c_{0}^{2}[w > c in N_{2}.

In this case T_{1} and T_{2} can occur only once. Thus, our specification is simpler. In terms of propositional variables, the property can be expressed as:

• SERIALIZABILITY:

1. p_{1} ∧ p_{2} ∧ p_{9} ⇒ AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})),

2. AG[((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})) ⇒ AF (P (p_{7} ∧ p_{8} ∧ p_{9}) ∨ (p_{7} ∧ p_{8} ∧ p_{9}))].

In the following sections, it is shown how to prove the above property by model checking.

5 Acceptors for finite state trace systems and model generators

Firstly, we define formally a notion of a finite state model for CTL_{P}.

Definition 5.1 A model M = (F_{v_{0}}, V) (for a trace system T ) is said to be finite state, if there is an equivalence relation EQ ⊆ T r(T ) × T r(T ) in the set of traces of T satisfying the conditions of the Definition 2.1 and

3. for each τ, τ′ ∈ T r(T ), if τ EQ τ′, then V (τ) = V (τ′) (EQ respects V).

Then, we show how to represent finite state models in a finite way. First, we show how to represent frames by a special kind of labelled transition systems.

Now, the definitions of labelled transition systems and concurrent transition systems are given, and related to trace systems. Concurrent transition systems have been introduced in [40] and investigated by many authors (see [41, 42]).

Definition 5.2 (labelled transition system) A labelled transition system (lts) is a triple F = (W, Σ, →) such that:

1. W is a non-empty, countable set of states,

2. Σ is a non-empty, countable set of actions,

3. → ⊆ W × Σ × W is a transition relation; we write w →^{a} w′ instead of (w, a, w′) ∈→,

The following notation is also used:

• w → w′, if there is a ∈ Σ s.t. w →^{a} w′,

• w →^{∗} w′, it there is a sequence of states w_{0}, …, w_{n} s.t. w = w_{0}, w′ = w_{n}, and w_{i} → w_{i+1} for 0 ≤ i < n.

Definition 5.3 (concurrent transition system) A concurrent transition system (cts) is a 4-tuple F = (W, Σ, →, I) such that:

1. (W, Σ, →) is a labelled transition system, 2. (Σ, I) is an independence alphabet,

3. (∀w, w′, w′′ ∈ W)(∀a, b ∈ Σ) : (w →^{a} w′ →^{b} w′′ and (a, b) ∈ I)

implies ∃w′′′: w →^{b} w′′′ →^{a} w′′,

4. (∀w, w′, w′′ ∈ W)(∀a, b ∈ Σ) : (w →^{a} w′ and w →^{b} w′′ and (a, b) ∈

I) implies ∃w′′′: w′ →^{b} w′′′ and w′′ →^{a} w′′′,

5. (∀w, w′, w′′ ∈ W)(∀a ∈ Σ): (w →^{a} w′ and w →^{a} w′′) implies w′ =

w′′.

Condition 3) requires that independent actions can commute, condition 4) is called a ”diamond property”. Condition 5) expresses unambiguity. In our case, this condition does not introduce any limitation, but it is convenient for using sequences of actions to denote paths.

Definition 5.4 Let F = (W, Σ, →, I) be a concurrent transition system and w_{0} ∈ W.

• F_{w_{0}} = (W, Σ, →, I, w_{0}) is said to be a rooted concurrent transition system - rcts, for short.

• A path in F_{w_{0}} is any finite or infinite sequence x = w_{0}a_{0}w_{1}a_{1} …

s.t. w_{i} →^{a_{i}} w_{i+1}, for i ≥ 0.

• en(w_{0}) = {a ∈ Σ | (∃w ∈ W) : w_{0} →^{a} w} is the set of all the actions enabled at w_{0}.

The following notations are used. Let x = w_{0}a_{0}w_{1}a_{1} … be a path in F_{w_{0}}.

• x/Σ = a_{0}a_{1} …,

• T r(F_{w_{0}}) = {[x/Σ] | x is a finite path in F_{w_{0}}},

• F_{w_{0}} is said to accept a trace system T over (Σ, I), if T r(T ) = T r(F_{w_{0}}).

• A path x is said to be an observation in F_{w_{0}}, if [ϵ][a_{0}][a_{0}a_{1}] … is an observation in T r(F_{w_{0}}).

• A suffix w_{i}a_{i}w_{i+1}a_{i+1} … of an observation x is said to be an observation starting at w_{i}.

Next, it is shown that rooted concurrent transition systems accept trace systems.

Fact 5.1 Let F_{w_{0}} be a rooted concurrent transition system. Then, T r(F_{w_{0}}) over (Σ, I) is a trace system.

Proof. It is easy to show that condition 4 in the definition of cts implies that T r(F_{w_{0}}) is proper and condition 3 guarantees that T r(F_{w_{0}}) is prefix-closed.

Moreover, all trace systems have got their acceptors.

Fact 5.2 Let T be any trace system. Then, there exists a rooted concurrent transition system F_{w_{0}} s.t. T r(F_{w_{0}}) = T r(T ).

Proof. Clearly, F_{w_{0}} = (T r(T ), Σ, →, I, [ϵ]) is a rooted concurrent transition system, accepting T , where τ →^{a} τ′ iff τ′ = τ[a], for a ∈ Σ.

If a trace system T is finite state and EQ is an equivalence relation in T r(T ), as described in the Definition 2.1, then there exists a finite rooted concurrent transition system accepting T .

Definition 5.5 The quotient structure of T r(T ) by EQ is a 5-tuple F_{w_{0}} = (W, Σ, →, I, w_{0}), where:

• W = {[τ]_{EQ} | τ ∈ T r(T )} is a set of states,

• (Σ, I) is an independence alphabet,

• → ⊆ W ×Σ×W is a transition relation such that [τ]_{EQ} →^{a} [τ′]_{EQ}, if there are traces τ_{1} ∈ [τ]_{EQ}, τ′_{1} ∈ [τ′]_{EQ}, and a ∈ Σ s.t. τ_{1}[a] = τ′_{1},

• w_{0} = [ϵ]_{EQ}.

It is easy to check that F_{w_{0}} is a rooted concurrent transition system accepting T . Therefore, if a trace system T and an equivalence relation EQ in T r(T ) is given, then Definition 5.5 shows how to define the finite rcts accepting T .

Example 5.1 (acceptors for trace systems) Below, we show the definitions of finite acceptors for the trace systems T_{1} and T_{2} of the Examples 3.2 and 3.3.

[figure: 4; 2,3; 2,5; 1,3; 1,5; d; c; c; d; b; a; a; Figure 5: The rcts F_{1} accepting the trace system T_{1}]

The rcts F_{w_{0}^{1}}^{1} = (W_{1}, Σ_{1}, →_{1}, I_{1}, w_{0}^{1}) accepting the trace system T_{1} is defined as follows:

• W_{1} = {{1, 3}, {1, 5}, {4}, {2, 3}, {2, 5}},

• Σ_{1} = {a, b, c, d},

• →_{1}= {({1, 3}, b, {4}), ({1, 3}, a, {2, 3}), ({1, 3}, c, {1, 5}),

({1, 5}, d, {1, 3}), ({1, 5}, a, {2, 5}),

({2, 5}, d, {2, 3}), ({2, 3}, c, {2, 5})},

• I_{1} = {(a, c), (c, a), (d, a), (a, d)},

• w_{0}^{1} = {1, 3}.

One can easily notice that, in this case, F_{w_{0}^{1}}^{1} is the sequential case graph of N_{1}, extended by the dependence relation. The trace system T_{2} itself defines the finite rcts F_{w_{0}^{2}}^{2} = (W_{2}, Σ_{2}, →_{2}, I_{2}, w_{0}^{2}), where:

• W_{2} = T r(T_{2}),

• Σ_{2} = {a_{1}, a_{2}, a_{3}, b_{1}, b_{2}, b_{3}},

• τ →_{2}^{a} τ′ iff τ[a] = τ′,

• I_{2} = Σ_{2} × Σ_{2} − ({a_{2}, a_{3}, b_{2}, b_{3}}^{2}∪

{(a_{1}, a_{1}), (b_{1}, b_{1}), (a_{1}, a_{2}), (a_{2}, a_{1}), (b_{1}, b_{2}), (b_{2}, b_{1})}),

• w_{0}^{2} = [ϵ].

Now, let F_{w} = (W, Σ, →, I, w) be a rcts. Define an acceptance function AC : T r(F_{w}) ⟶ W assigning to each trace from T r(F_{w}) the state of F_{w} which accepts this trace, i.e., AC(τ) = w′ iff there is a finite path x from w to w′ s.t. [x/Σ] = τ. Thanks to the conditions 4) and 5) in Definition 5.3, AC is defined correctly. In the standard way AC is extended on subsets of T r(F_{w}): AC(P) = {AC(τ) | τ ∈ P }, for P ⊆ T r(F_{w}).

Now, we define the notion of a model generator for a finite state model for a trace system T .

Definition 5.6 Let M = (F_{v_{0}}, V) be a finite state model for a trace system T , and let EQ be an equivalence relation in T r(T ) respecting V. Then, a model generator for M is defined as M_{G} = (F_{w_{0}}, V_{G}), where F_{w_{0}} is the quotient structure of T r(T ) by EQ and V_{G} : [T r(T )]_{EQ} ⟶ 2^{P V} s.t. V_{G}([τ]_{EQ}) = V (τ), for any τ ∈ T r(T ).

We say that a formula φ is true in a model generator M_{G} at w_{0} (written M_{G}, w_{0} ⊧ φ), if M, v_{0} ⊧ φ.

Before discussing a model checking algorithm for CTL_{P}, we show that, in fact, we can restrict ourselves to give an algorithm for CTL_{P −} - the restriction of CTL_{P} without nested past modalities and still we can check all the properties we are interested in. The only property, we have discussed, which required nested past operators, was serializability. But we show that for checking serializability, we can use a model checking algorithm for CTL_{P −}. This follows from the following observation. Let M_{τ} be a restriction of the model M to states ↑ τ ∩ T r(T ) i.e., M_{τ} is a submodel of M, generated by τ. Let θ be a proposition which holds only at the beginning state of each model M_{τ} i.e., θ ≡ Hfalse. Notice that:

• M ⊧ SER1 ∧ SER2 ∧ SER3 iff for each τ ∈ T r(T ): M_{τ} ⊧ SER1′ ∧ SER2′ ∧ SER3′, where

SER1′: (⋀_{i=1}^{2} quiescent_{i}) ⇒ AF (⋀_{i=1}^{2} P (active_{i}))

SER2′: (⋁_{i=1}^{2} active_{i}) ⇒ AF P (⋀_{i=1}^{2} quiescent_{i})

SER3′: (⋀_{i=1}^{2} quiescent_{i}) ⇒ AG((⋀_{i=1}^{2}(quiescent_{i} ∧ P (active_{i})) ⇒ P (⋀_{i=1}^{2} quiescent_{i} ∧ ¬θ))

Since M is a finite state model, then there are at most |EQ| nonisomorphic submodels M_{τ}. Let M_{G} = (F_{w_{0}}, V_{G}), where F_{w_{0}} = (W, Σ, → , I, w_{0}) be a model generator for M and let M_{G}^{w} = (F_{w}, V_{G}^{w}) be a model generator for M_{τ}, where AC(τ) = w ∈ W. Consequently, M ⊧ SER1 ∧ SER2 ∧ SER3 iff M_{G}^{w}, w ⊧ SER1′ ∧ SER2′ ∧ SER3′, for each w ∈ W.

Therefore, fortunately we can give a model checking algorithm for CTL_{P −} and we can still verify all the properties, discussed so far.

Unfortunately, as we show in the next section, model checking for CTL_{P −} is NP-hard.

6 NP-hardness of CTL_{P} model checking

In this section we show that model checking for CTL_{P −}, and therefore for CTL_{P} is NP-hard. Our problem has the following formulation: given a model generator M_{G} = (F_{w_{0}}, V_{G}) and a formula φ, is φ true in M_{G} at w_{0} ?

We prove that 3-SAT problem is polynomialy reducible to determining whether M_{G}, w_{0} ⊧ φ, for some CTL_{P} formula φ.

182 W. Penczek

Let ψ = c_{1} ∧ … ∧ c_{m} be a boolean formula in 3-CNF, where c_{i} = l_{i_{1}} ∨ l_{i_{2}} ∨ l_{i_{3}}, for 1 ≤ i ≤ m, l_{i_{j}} = x_{k} or ¬x_{k} for some k s.t. 1 ≤ k ≤ n, x_{1}, …, x_{n} are the propositional variables appearing in ψ.

Let M_{G} = (F_{w_{0}}, V_{G}) be a model generator (see the figure below), defined as follows:

• let X = {x_{i} | 1 ≤ i ≤ n} ∪ {x′_{i} | 1 ≤ i ≤ n}, Y = {y_{i} | 0 ≤ i ≤ n},

• F_{w_{0}} = (W, Σ, →, I, w_{0}), where

• W = X ∪ Y, Σ = X × Y ∪ Y × X, I = ∅,

• →= {(y_{i−1}, (y_{i−1}, x_{i}), x_{i}), (y_{i−1}, (y_{i−1}, x′_{i}), x′_{i}), (x_{i}, (x_{i}, y_{i}), y_{i}), (x′_{i}, (x′_{i}, y_{i}), y_{i}) | 1 ≤ i ≤ n},

• w_{0} = y_{0},

• P V = {c_{i} | 1 ≤ i ≤ m},

• V (x_{i}) = {c_{j} | x_{i} appears as a literal in c_{j}},

• V (x′_{i}) = {c_{j} | ¬x_{i} appears as a literal in c_{j}},

• V (y_{i}) = ∅, for 0 ≤ i ≤ n.

[figure: y_{0}; x_{1}; x′_{1}; y_{1}; x_{2}; x′_{2}; y_{2}; y_{n−1}; x_{n}; x′_{n}; y_{n}; Figure 8: The structure F_{w_{0}} of the model generator M_{G}]

The following equivalence holds: *) ψ is satisfiable iff M_{G}, w_{0} ⊧ EF (P c_{1} ∧ … ∧ P c_{m}).

The above follows from the fact that since the dependence relation I = ∅, therefore the model, generated by M_{G}, is a tree. Therefore, all c_{i} must be true somewhere at the same path, which represents one of the possible valuations of propositional variables x_{i}. This reduction is polynomial. Hence, model checking for CTL_{P} is NP-hard.

In fact we have proved even more. Namely, that model checking is NP-hard, even if past modalities cannot be nested, i.e., model checking for CTL_{P −} is NP-hard.

The next part of this paper is devoted for defining a model checking algorithm for CTL_{P −} and then, it is shown how our method can be extended to cover the whole language of CTL_{P}.

7 Model checking for CTL_{P −}

Altough, CTL_{P −} seems to be a very mild extension of CT L, it turns out that using a model checking algorithm for CTL_{P −} we can check all the partial order properties, we have discussed so far. Therefore, a model checking method for CTL_{P −} is of interest. Because of NP-hardness, we can hardly believe in a polynomial time model checking algorithm. Thus, the best we can offer is an algorithm of one exponential complexity. Moreover, as we show later, as soon as we know how to check CTL_{P −} formulas we can apply this method to the whole language of CTL_{P} and its extension to CTL_{P}^{∗}.

Unfortunately, any of the known methods for model checking, applied to CTL or CTL*, cannot be used in the case of CTL_{P −}. Showing why all these methods fail is going to be a good introduction to our method of model checking.

Let M_{G} = (F_{w_{0}}, V_{G}) be a model generator for M (we assume that the set P V of propositional variables is finite) and ψ be a CTL_{P −} formula to be checked over. Firstly, let’s try to apply a method, used for CTL [21]. Immediately we find an obstacle. We do not know how to label states of a model generator M_{G} with subformulas of ψ containing past operators. This problem stems from the fact that it may happen that for some τ, τ′ ∈ T r(F_{w_{0}}): AC(τ) = AC(τ′) = w in M_{G} and for some Hφ ∈ Subformulas(ψ), M, τ ⊧ Hφ and M, τ′ ⊧ ¬Hφ.

Secondly, let’s try to apply a method, used for LTTL [19] and CTL* [24]. Define a cross product of M_{G} with all subsets of Subformulas(ψ)∪ P V. Then, we can obtain a structure which is not a concurrent transition system. In fact, it can violate all the conditions, but that, which cannot be repaired is a diamond property. It may happen that for some trace τ, two different states w and w′ in the new structure accept it. Since, w and w′ may have been assigned different formulas, therefore our construction fails.

Looking at automata theoretic constructions [20] we realize that the same problems appear as in the former case. Therefore, we need a new technique. The general idea is to unwind M_{G} s.t. we can assign past formulas to states of a new structure and then use the most efficient method of CTL model checking, tunned to observations.

Let F_{w_{0}} = (W, Σ, →, I, w_{0}) be a rcts, w ∈ W, W′ ⊆ W, and τ ∈ [Σ^{∗}]. The following notations are used:

• Σ(τ) = {a ∈ Σ | τ = τ_{1}[a]τ_{2}, for some τ_{1}, τ_{2} ∈ [Σ^{∗}]} is the set of action names “occurring” in the trace τ.

• en(w, W′) = {a ∈ Σ | (∃w′ ∈ W′) : w →^{a} w′} defines actions,

enabled at w and leading to the states from W′,

• Σ_{I} = {a ∈ Σ | (∃b ∈ Σ) (a, b) ∈ I} is the set of actions for wich there is at least one independent action,

• I(Σ) = {Σ′ ⊆ Σ | (∃a ∈ Σ) : {a} × Σ′ ⊆ I} ∪ {Σ} is the family of sets of actions Σ′ s.t. there is at least one action independent with all its elements or Σ′ = Σ.

We need the following lemmas.

Lemma 7.1 A maximal path x = w_{0}a_{0}w_{1}a_{1} … is an observation in F_{w_{0}} iff

(∀a ∈ Σ)(∀i ∈ IN)(∃j ≥ i)(a ∉ en(w_{j}or ((a, a_{j}) ∉ I))

Proof follows directly from Lemma 2.1.

Obviously, the above lemma holds also for observations starting at any w ∈ W.

The next lemma is a special case of Levi’s Lemma for traces [17]. We present it with a short proof.

Lemma 7.2 For each τ, τ_{1}, τ_{2} ∈ [Σ^{∗}] and α ∈ [Σ] the following condition holds:

τα = τ_{1}τ_{2} iff

1) τ_{2} = τ′′α and τ_{1}τ′′ = τ, for some τ′′ ∈ [Σ^{∗}] or

2) τ_{1} = τ′α, {a} × Σ(τ_{2}) ⊆ I, and τ′τ_{2} = τ, for some τ′ ∈ [Σ^{∗}] and [a] = α.

Proof.(<=) Obvious. (=>) Let w be any linearisation of τα. Then w must be of the following form w = w′aw′′, where [w′w′′] = τ, [a] = α, and {a}×Σ([w′′]) ⊆ I, (where {a}×∅ = ∅). Now, if we represent w by concatenation of two strings w_{1}, w_{2} s.t. w = w_{1}w_{2}, then the following cases are possible:

• w_{1} = w′_{1} and w_{2} = w′_{2}aw′′, where w′ = w′_{1}w′_{2}, or

• w_{1} = w′aw′′_{1} and w_{2} = w′′_{2}, where w′′ = w′′_{1}w′′_{2}.

Now, let τα = τ_{1}τ_{2}. Therefore, either τ_{1} = [w′_{1}] and τ_{2} = [w′_{2}aw′′], where w′ = w′_{1}w′_{2} and {a} × Σ([w′′]) ⊆ I, or τ_{1} = [w′aw′′_{1}] and τ_{2} = [w′′_{2}], where w′′ = w′′_{1}w′′_{2} and {a} × Σ([w′′]) ⊆ I. This implies that either τ_{1} = [w′_{1}] and τ_{2} = τ′′[a], where τ′′ = [w′_{2}w′′], τ_{1}τ′′ = [w′_{1}w′_{2}w′′] = [w′w′′] = τ, or τ_{1} = τ′[a], {a} × Σ([w′′_{2}]) ⊆ I, and τ_{2} = [w′′_{2}], where τ′ = [w′w′′], τ′τ_{2} = [w′w′′_{1}w′′_{2}] = [w′w′′] = τ.

Let M_{G} = (F_{w_{0}}, V_{G}) be a model generator, where F_{w_{0}} = (W, Σ, → , I, w_{0}), and let AC be the acceptance function for F_{w_{0}}. Let ψ be a formula to be checked over the model, generated by M_{G}. The general idea of our algorithm consists in defining a new model generator M′_{G} for which AC′(τ) = AC′(τ′) implies 186 W. Penczek

• AC(↓ τ) = AC(↓ τ′), and

• for each a s.t. Y_{a}φ ∈ Subformulas(ψ), if τ = τ_{1}[a], then τ′ = τ′_{1}[a]

and AC(τ_{1}) = AC(τ′_{1}), for some τ_{1}, τ′_{1} ∈ [Σ^{∗}]. The model generator M′_{G} is built around the rcts accepting T r(F_{w_{0}}), being the quotient structure of T r(F_{w_{0}}) by the relation EQ. This relation is defined below.

Let τ, τ′ ∈ T r(F_{w_{0}}) and Δ ⊆ Σ. We define:

• I_{ψ}(Σ) = I(Σ) ∪ {{a} ⊂ Σ | Y_{a}φ ∈ Subformulas(ψ)},

• a function ^{−} : 2^{Σ} ⟶ I_{ψ}(Σ) s.t. \overline{Δ} = Δ, if Δ ∈ I_{ψ}(Σ), \overline{Δ} = Σ, if Δ ∉ I_{ψ}(Σ),

• a function p : [Σ^{∗}] ⟶ {tt, ff} s.t. p(τ′) = tt, if |τ′| = 1, p(τ′) = ff, if |τ′| ≠ 1,

• a function Rep : [Σ^{∗}] ⟶ 2^{W ×I_{ψ}(Σ)×{tt,ff}} (tt stands for true and ff stands for false) s.t.

• Rep(τ) = \{(AC(τ_{1}), \overline{Σ(τ_{2})}, p(τ_{2})) | τ_{1}τ_{2} = τ\},

• τ EQ τ′ iff Rep(τ) = Rep(τ′),

• [τ]_{EQ} = {τ′ ∈ T r(F_{w_{0}}) | τ EQ τ′},

• states(τ) = {w ∈ W | (w, Δ, q) ∈ Rep(τ), for any non-empty Δ ⊆ Σ and any q ∈ {tt, ff}}. Intuitively speaking, states(τ) gives the set of all states in W accepting strict prefixes of τ,

• pred(τ) = {(w, Δ, q) ∈ Rep(τ) | q = tt}, Intuitively speaking, pred(τ) is the set of all states in W accepting predecessors of τ.

The definition of Rep(τ) gives rise to the equivalence relation satisfying the conditions of Definition 2.1 and carrying information about the past and predecessors of traces. The interested reader can check that Rep(τ), defined as {AC(τ′) | τ′ ≤ τ} or {AC(τ′) | τ′ → τ} wouldn’t give rise to an equivalence relation as required.

Next, it is shown that EQ is indeed an equivalence relation, which can be used for defining a new finite representation of T r(F_{w_{0}}).

Lemma 7.3 The following conditions hold:

i) τ EQ τ′ implies AC(τ) = AC(τ′),

ii) EQ satisfies the conditions of the Definition 2.1,

iii) τ EQ τ′ implies states(τ) = states(τ′) and pred(τ) = pred(τ′).

Proof.

i) Assume that τ EQ τ′. From the definition of Rep(τ), it follows that AC(τ) = w for (w, ∅, ff) ∈ Rep(τ) (it is exactly one element in Rep(τ) of the form (w, ∅, ff)). As Rep(τ) = Rep(τ′), it follows that AC(τ) = AC(τ′).

ii) The index of EQ is obviously finite and moreover, it can be shown to be smaller than 2^{2×|W |×|I_{ψ}(Σ)|}.

Then, we prove that τ EQ τ′ and τα ∈ T r(F_{w_{0}}) implies τα EQ τ′α, for each α ∈ [Σ]. To this end we show that Rep(τα) can be defined in terms of Rep(τ), α, and (Σ, I). We need the following notation: for each w ∈ W and a ∈ en(w), by w(a) we denote the state w′ ∈ W s.t. w →^{a} w′.

Now, we come back to the proof of ii). Let α = [a].

• Rep(τα) = (by definition) \{(AC(τ_{1}), \overline{Σ(τ_{2})}, p(τ_{2})) | τ_{1}τ_{2} = τα} = (by Lemma 7.2)

• \{(AC(τ_{1}), \overline{Σ(τ′′α)}, p(τ′′α)) | τ_{1}τ′′ = τ\}∪ \{(AC(τ′α), \overline{Σ(τ_{2})}, p(τ_{2})) | τ′τ_{2} = τ and \{a\}×Σ(τ_{2}) ⊆ I\} = (by definition of Rep(τ))

• \{(w, \overline{Δ ∪ \{a\}}, emp(Δ)) | (w, Δ, q) ∈ Rep(τ)\}∪ {(w(a), Δ, q) | (w, Δ, q) ∈ Rep(τ) and {a} × Δ ⊆ I}, where emp(Δ) = tt, if Δ = ∅, and emp(Δ) = ff, otherwise.

Notice that, Rep(τα) = Rep(τ′α), if Rep(τ) = Rep(τ′). iii) It follows directly from the definitions of EQ, states(τ) and pred(τ).

Let F′_{w′_{0}} = (W′, Σ, →′, I, w′_{0}) be the quotient structure of T r(F_{w_{0}}) by the equivalence relation EQ s.t. elements of W′ are of the form Rep(τ) for τ ∈ T r(F_{w_{0}}) rather than [τ]_{EQ}. We show now that F′_{w′_{0}} can be defined directly from F_{w_{0}}.

The following notions simplify the rest of the construction.

We define:

• a function last : W′ ⟶ W, s.t. last(w′) = w, if (w, ∅, ff) ∈ w′,

• REP (w′a) = \{(w, \overline{Δ ∪ \{a\}}, emp(Δ)) | (w, Δ, q) ∈ w′\} ∪ {(w(a), Δ, q) | (w, Δ, q) ∈ w′ and {a} × Δ ⊆ I}, for any w′ ∈ W′ and a ∈ en(last(w′)), (intuitively speaking, REP (w′a) defines the next state in W′, reached after executing a at w′),

The construction of F′_{w′_{0}} is performed inductively, in stages.

Let F_{w′_{0}}^{1} = (W′_{1}, Σ, ∅, I, w′_{0}), where W′_{1} = {w′_{0}} and w′_{0} = {(w_{0}, ∅, ff)}. Now, for each node w′ of W′_{i} − W′_{i−1} (with W′_{0} = ∅) we add all its successors in W′ and extend →′_{i}, respectively. Let F_{w′_{0}}^{i} = (W′_{i}, Σ, →′_{i}, I, w′_{0}) and W_{i}^{∅} = W′_{i} − W′_{i−1}. Then, F_{w′_{0}}^{i+1} = (W′_{i+1}, Σ, →′_{i+1}, I, w′_{0}), where

• W′_{i+1} = W′_{i} ∪ {REP (w′a) | w′ ∈ W_{i}^{∅}, a ∈ en(last(w′))},

• →′_{i+1}=→′_{i} ∪{(w′, a, REP (w′a)) | w′ ∈ W_{i}^{∅}, a ∈ en(last(w′))}.

The construction stops at the least m, when F_{w′_{0}}^{m} = F_{w′_{0}}^{m+1}. It is easy to see that F_{w′_{0}}^{m} is isomorphic to F′_{w′_{0}}. Then, the new model generator M′_{G} = (F′_{w′_{0}}, V′) is defined as follows:

• F′_{w′_{0}} = (W′, Σ, →′, I, w′_{0}), • V′_{G} : W′ ⟶ 2^{P V} is a valuation function satisfying the following

condition:

– p ∈ V′_{G}(w′) iff p ∈ V_{G}(last(w′)), for p ∈ P V.

7.1 Improving the algorithm

In order to decrease the number of elements of W′ we may require that:

• if (w, Δ, tt) ∈ Rep(τ), then (w, Δ, ff) ∉ Rep(τ),

• if (w, Δ, ff) ∈ Rep(τ), then (w, Δ′, ff) ∉ Rep(τ), for Δ ⊂ Δ′ and Δ ≠ Δ′.

The definition of Rep(τ) with these changes remains correct. To estimate the complexity of the algorithm we have to assess how much it does cost to build M′_{G}. Therefore, notice that:

• |W′| ≤ 2^{2×|W |×|I_{ψ}(Σ)|}.

• Checking whether {a}×Δ ⊆ I, for all a ∈ Σ_{I} and for all Δ ∈ I_{ψ}(Σ) costs |Σ_{I}| × |I_{ψ}(Σ)| × |Σ_{I}| × |I|.

• Checking whether Δ ∪ {a} ∉ I_{ψ}(Σ), for all a ∈ Σ_{I} and for all Δ ∈ I_{ψ}(Σ) costs |Σ_{I}| × |I_{ψ}(Σ)| × |Σ_{I}| × |I|, since for each a ∈ Σ_{I} and Δ ∈ I_{ψ}(Σ) the algorithm can check whether ({a}×Con(Δ))∩ I ≠ ∅, where Con(Δ) = {a′ ∈ Σ | {a′} × Δ ⊆ I} (Con(Δ) has been already computed by the algorithm while checking whether {a} × Δ ⊆ I, for all a ∈ Σ_{I}), which costs at most |Σ_{I}| × |I|.

• At each state w′ of W′ the cost of calculating the next states is O(|W | × |I_{ψ}(Σ)|) for each a ∈ en(last(w′)) i.e., O(| → | × |I_{ψ}(Σ)|). Thus, for all states w′ ∈ W′ it is O(| → |×|I_{ψ}(Σ)|×2^{2×|W |×|I_{ψ}(Σ)|}).

Therefore, the complexity of building M′_{G} is:

O(| → | × |I_{ψ}(Σ)| × 2^{2×|W |×|I_{ψ}(Σ)|}).

Notice that for each subformula φ of ψ and for each τ, τ′ ∈ T r(F_{w_{0}}), if AC′(τ) = AC′(τ′), then M, τ ⊧ φ iff M, τ′ ⊧ φ. Therefore, we label w′ ∈ W′ with φ (written M′_{G}, w′ ⊧ φ), if M, τ ⊧ φ, for some τ: AC′(τ) = w′.

Obviously, for each subformula φ without past operators, for each τ, τ′ ∈ T r(F_{w_{0}}), if AC(τ) = AC(τ′), then M, τ ⊧ φ iff M, τ′ ⊧ φ. Therefore, we label w ∈ W with φ (written M_{G}, w ⊧ φ), if M, τ ⊧ φ, for some τ: AC(τ) = w.

We write M_{G} ⊧ φ, if M_{G}, w ⊧ φ, for all w ∈ W.

Next, we show model checking algorithms. The method is inductive i.e., given a formula ψ, starting from its shortest and most deeply nested subformula φ the algorithm labels these states of M′_{G} with φ, which accept traces, at which φ holds. Therefore, in case of checking a less nested subformula, it can be assumed that the states have just been labelled with all its subformulas.

Firstly, we label states of M_{G} with all the subformulas of ψ, which do not contain past subformulas. Then, we label states of M′_{G} with all the subformulas of ψ. Below, we give algorithms for labelling states of M′_{G}. These algorithms can be as well applied for labelling states of M_{G}.

We show how to label states of M′_{G} with formulas of the form p, ¬φ, φ ∧ γ, Y_{a}φ, Hφ, EX_{a}φ, EGφ, and E(φUγ).

7.2 Model checking for p, ¬φ, φ ∧ γ

There is not a lot to do in the case of checking formulas of the form:

• p ∈ P V,

• ¬φ,

• φ ∧ γ.

Notice, that:

1. M′_{G}, w′ ⊧ p iff p ∈ V′_{G}(w′), for p ∈ P V,

2. if φ, γ are state formulas,

M′_{G}, w′ ⊧ ¬φ iff not M′_{G}, w′ ⊧ φ,

M′_{G}, w′ ⊧ φ ∧ γ iff M′_{G}, w′ ⊧ φ and M′_{G}, w′ ⊧ γ.

Therefore, in the first case we check whether p is an element of V′_{G}(w′), in the second case we check whether w′ has been labelled with φ and in the third case we check whether w′ has been labelled with φ and γ. The complexity of checking a formula of the above form over all states is O(|W′|).

Now, we define algorithms for checking formulas of the form Y_{a}φ, Hφ, EX_{a}φ, E(φUγ), and EGφ.

7.3 Model checking for Y_{a}φ

Observe that M′_{G}, w′ ⊧ Y_{a}φ iff there is (w, {a}, tt) ∈ w′ s.t. M_{G}, w ⊧ φ. The complexity of labelling states of M′_{G} with Y_{a}φ is O(|W′| × |W | × |I_{ψ}(Σ)|).

7.4 Model checking for Hφ

Observe that M′_{G}, w′ ⊧ Hφ iff for all (w, Δ, q) ∈ w′ if Δ ≠ ∅, then M_{G}, w ⊧ φ. The complexity of labelling states of M′_{G} with Hφ is O(|W′| × |W | × |I_{ψ}(Σ)|).

7.5 Model checking for EX_{a}φ

Observe that M′_{G}, w′ ⊧ EX_{a}φ iff there is w′′ ∈ W′ s.t. w′ →^{a} w′′ and M′_{G}, w′′ ⊧ φ. Therefore, the algorithm finds all the states at which φ holds and labels all its a-predecessors with EX_{a}φ. The complexity of labelling states of M′_{G} with EX_{a}φ is O(|W′| + | →′ |).

7.6 Model checking for E(φUγ)

Observe that M′_{G}, w′ ⊧ E(φUγ) iff there is a state w′′ ∈ W′ and a sequence of states w′_{0}, …, w′_{n} ∈ W′ s.t. w′ = w′_{0} → … → w′_{n} = w′′ and M′_{G}, w′′ ⊧ γ, M′_{G}, w′_{i} ⊧ φ for 0 ≤ i < n.

The above follows from the following lemma:

Lemma 7.4 Every finite path in F′_{w′_{0}} can be extended to an observation in F′_{w′_{0}}.

Proof follows from the fact that every finite path in T r(F′_{w′_{0}}) can be extended to an observation in T r(F′_{w′_{0}}) (see [17]).

Firstly, all the states at which γ holds are labelled with E(φUγ). Secondly, the algorithm goes backwards using the relation →^{′−1} and labels all states at which φ holds with E(φUγ). The complexity of labelling states with E(φUγ) is O(|W′| + | →′ |).

7.7 Model checking for EGφ

We assume that I ≠ ∅. Observe that M′_{G}, w′ ⊧ EGφ iff there is an observation x starting at w′ s.t. M′_{G}, w′′ ⊧ φ, for each w′′ on x. The model checking algorithm uses Lemma 7.1.

Let W′_{φ} = {w′ ∈ W′ | M′_{G}, w′ ⊧ φ} be the subset of W′, labelled with φ. Firstly, the subset W′_{φ} of W′ is selected. By a strongly connected component in W′_{φ} we mean any subset W′′ ⊆ W′_{φ} satisfying one of the following conditions:

• (∀w_{1}, w_{2} ∈ W′′): w_{1} →^{′∗} w_{2} and w_{2} →^{′∗} w_{1}, or

• W′′ contains only one state w′′ s.t. w′′ does not have any successor in W′.

Secondly, all the maximal strongly connected components in W′_{φ} are selected. Notice that they are disjoint. Next, the states of W′ are labelled according to the following theorem:

Theorem 7.1 M′_{G}, w′_{0} ⊧ EGφ iff w′_{0} ∈ W′_{φ} and there is a maximal strongly connected component W′′ in W′_{φ} reachable from w′_{0} by a path contained in W′_{φ} and (*): (∀a ∈ Σ)(∃w′ ∈ W′′) a ∉ en(w′) or {a} × en(w′, W′′) ⊈ I.

Proof. (=>). If M′_{G}, w′_{0} ⊧ EGφ, then there is an observation starting at w′_{0}, say x = w′_{0}a_{0}w′_{1}a_{1} …, s.t. (∀i ≥

0) M′_{G}, w′_{i} ⊧ φ. If x is finite, then the last state of x is a maximal strongly connected component in W′_{φ} satisfying (*).

Thus, let’s assume that x is infinite. Let w′′ be the first state on x s.t. each w′ ∈ W′ either doesn’t appear on x after w′′ or appears infinitely many times. Then, the set W′′ of all states appearing on x after w′′ is a strongly connected component. It follows from Lemma 7.1 that W′′ satisfies the required property. If W′′ is not a maximal strongly connected component, then it can be extended to it and the property in question is preserved.

(<=). If W′′ contains only one state without any successor in W′, then obviously M′_{G}, w′_{0} ⊧ EGφ. So, assume that this is not true. Take any path x = w′_{0}a_{0}w′_{1}a_{1} … s.t.

(∀i ≥ 0) w′_{i} ∈ W′_{φ} and (∀w′, w′′ ∈ W′′) if w′ →′^{a} w′′, then for

infinitly many i: w′_{i} = w′, w′_{i+1} = w′′, and a_{i} = a. Clearly, by the assumption and by Lemma 7.1, it follows that x is an observation and by construction x ⊧ Gφ.

Selecting W′_{φ} and maximal strongly connected components costs O(|W′|+| →′ |) (see [21]). Then, components satisfying the property (*) in the Theorem 7.1 are labelled. This may cost O((|W′|+| →′ | )×|Σ|× |I|). If w′_{0} is in W′_{φ} and there is a path from w′_{0} to a labelled component in W′_{φ}, then M′_{G}, w′_{0} ⊧ EGφ, otherwise M′_{G}, w′_{0} ⊧ ¬EGφ. Therefore, the complexity of checking EGφ is O(|Σ| × |I| × (|W′| + | →′ |)).

7.7.1 Improving the algorithm

Now, it is shown how to improve the algorithm. The above algorithm will be more efficient, if instead of checking for all a ∈ Σ, it will check only for those a, for which it exists at least one independent action i.e., a ∈ Σ_{I}. If a ∉ Σ_{I}, then {a} × en(w′, W′′) ⊈ I, so this does not need to be checked. Finding the set Σ_{I} costs O(|I|). Therefore, the complexity of the improved algorithm is

O(|Σ_{I}| × |I| × (|W′| + | →′ |)).

It was assumed that I ≠ ∅. In the other case, each path is an observation, so to prove that EGφ holds does not require to check any property about maximal strongly connected components. Then, the complexity is O(|W′| + | →′ |).

7.8 Complexity of CTL_{P −} model checking

In order to handle an arbitrary CTL_{P −} formula ψ, the state-labelling algorithm is applied to the subformulas of ψ starting with the shortest and most deeply nested one. Since |Σ_{I}| × |I| ≤ |I_{ψ}(Σ)| and | →′ | ≤ | → | × |W′|, then each pass does not take more time than O(| → | × |I_{ψ}(Σ)| × 2^{2×|W |×|I_{ψ}(Σ)|}), and since ψ contains at most lenght(ψ) different subformulas, the algorithm requires time

O(lenght(ψ) × | → | × |I_{ψ}(Σ)| × 2^{2×|W |×|I_{ψ}(Σ)|}).

Example 7.1 (proving serializability) Below, it is shown how to prove serializability of the trace system T_{2}.

We have to check whether:

1. M_{2}, [ϵ] ⊧ p_{1} ∧ p_{2} ∧ p_{9} ⇒ AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})),

2. M_{2}, [ϵ] ⊧ AG[((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})) ⇒ AF (P (p_{7} ∧ p_{8} ∧ p_{9}) ∨ (p_{7} ∧ p_{8} ∧ p_{9}))].

Fortunately, in this case M_{2} is equall to its model generator. Therefore, we can carry out all the proofs over M_{2}. The only difficult thing is to label states of M_{2} with the formulas:

1. AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})),

2. AF (P (p_{7} ∧ p_{8} ∧ p_{9}) ∨ (p_{7} ∧ p_{8} ∧ p_{9})).

It is shown how to do that for the formula 1. First notice that: AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})) ≡ ¬EGHφ, where φ = (¬p_{7} ∨ ¬p_{2} ∨ ¬p_{9}) ∧ (¬p_{1} ∨ ¬p_{8} ∨ ¬p_{9}). Next, states of M_{2} are labelled with EGHφ. Notice that φ ∈ V_{2}(τ), if τ ∉ {[a_{1}a_{2}a_{3}], [b_{1}b_{2}b_{3}]}. Therefore, M_{2}, τ ⊧ Hφ iff τ ∉ (↑ [a_{1}a_{2}a_{3}]∪ ↑ [b_{1}b_{2}b_{3}]) − ([a_{1}a_{2}a_{3}] ∪ [b_{1}b_{2}b_{3}]). Now, using the algorithm for EGφ in M_{2}, we find that M_{2}, [ϵ] |̸= EGHφ. Thus, M_{2}, [ϵ] ⊧ AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})). Consequently, we get M_{2}, [ϵ] ⊧ p_{1} ∧ p_{2} ∧ p_{9} ⇒ AF P ((p_{7} ∧ p_{2} ∧ p_{9}) ∨ (p_{1} ∧ p_{8} ∧ p_{9})).

7.9 Extending model checking to CTL_{P} and CTL_{P}^{∗}

Our method of model checking can be easily extended s.t.:

1. past formulas can be nested - (model checking for CTL_{P}),

2. future formulas are those of CTL* [47] (CTL with nested path formulas) -

(model checking for CTL*_{P −}),

3. all the above extensions together - (model checking for CTL*_{P}).

For 1), we define a sequence of unfoldings M_{1}, …, M_{n}, where M_{1} = M′_{G}, n is the maximal depth of nested past formulas in ψ, M_{i+1} is obtained from M_{i} in the same way as M′_{G} was obtained from M_{G}. Then, we inductively label states of M_{i} with subformulas of ψ containing nested past formulas of depth at most i. Then, M, [ϵ] ⊧ ψ iff the beginning state of M_{n} is labelled with ψ. In the worst case we can arrive at the complexity exp_{n}(2 × |W | × |I_{ψ}(Σ)|).

In this case, the meaning of our result is only theoretical, but, at least, we have shown that it is decidable whether any CTL_{P} formula is true in a finite state trace model. This result seems to be interesting on its own, especially in comparison with the result of chapter 9.

For 2), after unwinding the model generator, we treat past formulas as fresh propositions and apply the standard methods for CTL* model checking [24]. Then, we arrive at the complexity exponential in the number of states and exponential in the number of subformulas of ψ.

For 3), we combine the methods of 1) and 2).

8 Undecidability of CTL_{P}

We now turn to the problem of determining the satisfiability of CTL_{P} formulas. This problem may be stated as: Given a CTL_{P} formula φ, is there a model M = (F_{v_{0}}, V) s.t. M, v_{0} ⊧ φ. If φ is true at v_{0} of M, M is said to be a model of φ. Note also that the CTL_{P} formula φ is satisfiable iff ¬φ is not valid, hence exhibiting a decision procedure for satisfiability amounts to deciding the validity problem.

Unfortunately, to our big surprise we have to report a negative result. CTL_{P} is not decidable ! It turns out that we can encode a grid using our language.

Consider a Petri Net N, composed of two independent transitions a and b, each of them can be executed infinitely many times. The trace system T giving the semantics to N is composed of all the traces belonging to the language [Δ^{∗}], where Δ = {a, b} and I = Δ × Δ − id_{Δ}. A frame for T is defined as F_{[ϵ]} = ([Δ^{∗}], →, [ϵ]), It is possible to characterize this frame up to isomorphism. But, then one can encode the following recurring tiling problem, which has been shown to be undecidable in [43]. Below, we follow the definition of [44] and [45].

Let Γ be a finite set of types of tiles such that for each T ∈ Γ each side - North, East, South and West - is assigned a number (N(T), E(T), S(T), and W(T), resp.). Let Co ⊆ Γ^{4} be a set of colors such that c = (T_{1}, T_{2}, T_{3}, T_{4}) ∈ Co iff S(T_{1}) = N(T_{3}), E(T_{1}) = W (T_{2}), N(T_{4}) = S(T_{2}), and W (T_{4}) = E(T_{3}) (see the picture below).

T_{3} T_{1} T_{4} T_{2}

For each c = (T_{1}, T_{2}, T_{3}, T_{4}) ∈ Co let U(c), R(c) ⊆ Co, where U stands for Up and R stands for Right, with U(c) = {c′ ∈ Co | c′ = (T, T′, T_{1}, T_{2}), for some T, T′}, R(c) = {c′ ∈ Co | c′ = (T_{2}, T, T_{4}, T′), for some T, T′}. Let T_{0}, T_{f} ∈ Γ be two special types. The problem is to find a coloring c : IN × IN ⟶ Co such that for all i, j ∈ N, c(i, j) ∈ Co, c(0, 0) ∈ {c′ ∈ Co | c′ = (T, T′, T_{0}, T′′), for some T, T′, T′′}, c(i, j +1) ∈ U(c(i, j)), and c(i+1, j) ∈ R(c(i, j)), and there are infinitely many colors in the leftmost column, which contain the tile type T_{f}. The above formulation means that one has to exhibit a coloring of the lattice points in the plane such that if a point has a color c, then the point just above has a color from the set U(c) and the point to the right has a color from the set R(c), the beginning has a color of a given subset of Co and the given tile type T_{f} occurs infinitely often in the leftmost column.

Let P V = {C_{i} | c_{i} ∈ Co}. Now, it is possible to give a set of formulas of CTL_{P −} s.t. its conjunction is satisfiable iff the recurring tiling problem has a solution. Firstly, we give formulas encoding the grid:

(A):

1. AG(EX_{a}true ∧ EX_{b}true)

2. AG(⋀_{c∈Σ−{a,b}} ¬EX_{c}true),

3. EF (Y_{a}true ∧ Y_{b}true)

1) expresses that two actions a and b are executed at each state. Since our model is a partially ordered set, therefore it contains infinitely many states. It follows from 2) that each of them has exactly two successors. 3) specifies that a and b are independent at some state. Thus, by definition of trace systems a and b are independent at each state. So, the frame is a grid representing a trace system [{a, b}^{∗}].

Now, we give formulas describing the tiling:

(B):

1. ⋁{C_{i} | c_{i} = (T, T′, T_{0}, T′′), for some T, T′, T′′},

2. AG(⋁({C_{i} | c_{i} ∈ Co}) ∧ (⋀{C_{i} ⇒ ¬C_{j} | i ≠ j})),

3. AG(⋀({C_{i} ⇒ EX_{a}(⋁{C_{j} | c_{j} ∈ U(c_{i})}) | c_{i} ∈ Co})),

4. AG(⋀({C_{i} ⇒ EX_{b}(⋁{C_{j} | c_{j} ∈ R(c_{i})}) | c_{i} ∈ Co})),

5. AG(¬Y_{b}true ⇒ EF (¬Y_{b}true∧⋁{C_{i} | type T_{f} occurs in color c_{i}})).

1) expresses that the tile type T at the beginning is T_{0}. 2) enforces exactly one color at each point of the grid. 3) and 4) ensures that successors have the right color. 5) requires that the tile type T_{f} occurs infinitely often in the leftmost column.

The recurring tiling problem has a solution iff the conjunction of our formulas A) and B) is satisfiable. As in [44], it follows that the validity problem for CTL_{P −} is π_{1}^{1} − hard.

It can be easily shown that our logic remains undecidable, even if it does not contain backward step operators, next step operators are not labelled, but a valuation function encodes labelling as shown in Example 4.1. Then, the formulas 1), 2) in A) and 3), 4) in B) can use unlabelled versions of next step operators (see Example 4.1), the formulas 3) in A) and 5) in B) can be replaced by:

3’. EXEX(p_{a} ∧ p_{b} ∧ P (p_{a} ∧ ¬p_{b}) ∧ P (p_{b} ∧ ¬p_{a})),

5’. AG(H(¬p_{b}) ∧ ¬p_{b} ⇒ EF (H(¬p_{b}) ∧ ¬p_{b} ∧ ⋁{C_{i} | type T_{f} occurs in color c_{i}})).

The undecidability result explains why we couldn’t use any standard methods for model checking.

9 Comparing CTL_{P} with other logics

CTL_{P} contains CTL and, as it was said before, it can be seen as a restricted version of the logic, defined in [16]. The language of CTL_{P} is an extension of that of Hennessy-Milner logic with backward modalities and a restriction of the language of POTL [3, 4]. CTL_{P} resembles also the partial order logic (P.O.-logic), introduced by A. Sinachopoulos [14], which, however, does not contain path quantifiers. A similar logic, but with run operators (PN-logic), has been also defined by Reisig in [11,12]. CTL_{P} differs from ISTL [13] in the definition of a frame; ISTL is interpreted on runs of trace systems.

Our results on undecidability of checking satisfiability as well as the method of model checking can be easily extended on propositional versions of the following logics: Hennessy-Milner logic with backward modalities [32], ISTL [13], P.O.-logic [14], and the logic defined in [16], interpreted over trace systems.

10 Final remarks

The presented approach to model checking for a partial order logic with past modalities over structures of global states is the first one, known from the literature. In [4] model checking for a similar logic, interpreted over local state models has been investigated. Our paper is also the first one showing how to prove properties of partial order executions, of serializability, and snapshots by model checking. Therefore, it is not possible to compare the complexity of the model checking algorithm with others.

Our method can be viewed as an extension and refinement of the method of Clarke and al. [21] to cover also partial order properties. The alternative approach would be to apply automata-theoretic techniques in the style of [20] or [31]. This, however, cannot be done immediately as it is not clear how to build automata accepting CTL_{P} formulas.

We have proved that model checking becomes NP-hard as soon as we have introduced backward modalities. Moreover, unfortunately, the best algorithm we could give is of exponential complexity in the number of states of a model and linear in the lenght of a formula. Therefore, our algorithm can be applied for systems with not too many states. It seems to be impossible to define an algorithm linear in the number of states of a model (and, obviously, exponential in the lenght of a formula).

Our undecidability result shows that in general it is not possible to synthesise systems from their specifications in CTL_{P −}, or any similar logic, e.g., defined in [13], [16]. Therefore, altough, serializability and run properties can be proved by model checking, they cannot be imposed on systems, synthesised from their specifications.

ACKNOWLEDGEMENTS: The author wishes to thank dr. Ruurd Kuiper for improving the language of the paper. Special thanks are directed to my wife Agnieszka for the help in designing the figures.

11 References

[1]: Manna, Z., Pnueli, A., The Anchored Version of the Temporal

Framework, LNCS 354, 1988.

[2]: Emerson, E.A., Srinivasan, J., Branching Time Temporal Logic, LNCS 354, 1988.

[3]: Pinter, S.S., Wolper,P., A Temporal Logic for Reasoning about Partially Ordered Computations, Proc. 3rd Symp. on Principles of Distributed Computing, pp. 28-37, Vancouver 1984.

[4]: Kornatzky, Y., Pinter, S.S., A Model Checker for Partial Order Temporal Logic, EE Pub n. 597, Department of Electrical Engineering, Technion - Israel Institute of Technology, 1986.

[5]: Katz, S., Peled, D., Interleaving Set Temporal Logic, 6th ACM Symposium on Principles of Distributed Computing, Vancouver Canada, pp. 178-190, 1987.

[6]: Katz, S., Peled, D., An Efficient Verification Method for Parallel and Distributed Programs, LNCS 354, 1988.

[7]: Lodaya, K., Thiagarajan, P.S., A Modal Logic for a Subclass of Event Structures, LNCS 267, pp. 290-303, 1987.

[8]: Penczek, W., A Temporal Logic for The Local Specification of Concurrent Systems, Information Processing, pp. 857-862, IFIP, 1989.

[9]: Penczek, W., A Concurrent Branching Time Temporal Logic, Proceedings of the Workshop on Computer Science Logic, Kaiserslautern, LNCS 440, pp. 337-354, 1990.

[10]: Mukund, M., Thiagarajan, P.S., An Axiomatization of Event Structures, LNCS 405, 1989.

[11]: Reisig, W., Temporal Logic and Causality in Concurrent Systems, LNCS 335, 1988.

[12]: Reisig, W., Towards a Temporal Logic of Causality and Choice in Distributed Systems, LNCS 354, pp. 606-627, 1989.

[13]: Peled, D., Pnueli, A., Proving Partial Order Liveness Properties, Proc. of ICALP, pp. 553-571, 1990.

[14]: Sinachopoulos A, Partial Order Logics for Elementary Net Systems: State- and Event - approches, Proc. of CONCUR’90, 1990.

[15]: Penczek, W., Proving Partial Order Properties Using CCTL, manuscript, 1991.

[16]: Peled, D., Katz, S., and Pnueli, A., Specifying and Proving Serializability in Temporal Logic, Proc. of LICS, 1991.

[17 ]: Mazurkiewicz, A., Basic Notions of Trace Theory, LNCS 354, pp. 285-363, 1988.

[18]: Mazurkiewicz, A., Ochmanski, E., Penczek, W., Concurrent Systems and Inevitability, TCS 64, pp. 281-304, 1989.

[19]: Lichtenstein, O., and Pnueli, A., Checking that Finite State Concurrent Programs Satisfy their Linear Specification. Proc. of the 12th ACM Symposium on Principles of Programming Languages, pp. 97-107, New Orleans, 1985.

[20]: Vardi, M.Y., Wolper. P., An Automata-Theoretic Approach to Automatic Program Verification, Proc. of LICS, pp. 322-331, 1986.

[21]: Clarke, E.M., Emerson, E.A., Sistla, A.P., Automatic Verification of Finite State Concurrent Systems Using Temporal Logic Specifications: A Practical Approach, Proc. 10th Annual ACM Symp. on Principles of Programming Languages, Austin, pp. 117-126, 1983, and ACM Transactions on Programming Languages and Systems, 8(2), pp. 244-263, 1986.

[22]: Sistla, A.P., Clarke, E., The Complexity of Propositional Temporal Logic, 14th ACM Symposium on Theory of Computing, May 1982, pp. 159-167.

[23]: Emerson, E.A., Clarke, E.M., Using Branching Time Logic to Synthesize Synchronization Skeletons, Science of Computer Programming, vol. 2, pp. 241-266, 1982.

[24 ]: Emerson, E.A., Lei, C.L., Modalities for Model Checking: Branching Time Logics Strikes Back, Science of Comp. Programming, vol. 8, pp. 275 - 306, 1987.

[25]: Emerson, E.A., Lei, C.L., Efficient Model Checking in Fragments of the Propositional μ-calculus, Proc. of LICS, 1986.

[26]: Emerson, E.A., Lei, C.L., Temporal Reasoning Under Generalized Fairness Constraints, LNCS 210, pp. 21-36, 1986.

[27]: Stirling, C., Walker, A General Tableau Technique for Verifying Temporal Properties of Concurrent Programs, in Semantics for Concurrency, eds. M.Z. Kwiatkowska, M.W. Shields, and R.M. Thomas, pp. 1-15, Leicester 1990.

[28]: Burch, J.R., Clarke E.M., McMillan, K.L., Dill, D.L., and Hwang L.J., Symbolic Model Checking: 10^{20} States and Beyond. Proc. of LICS, 1990.

[29]: Clarke, E.M., and Grumberg, O., Avoiding the State Explosion Problem in Temporal Logic Model-Checking Algorithms. Proc of 5th ACM Symposium on Principles of Distributed Computing, pp. 293-303, 1987.

[30]: Valmari, A., A Stubborn Attack on State Explosion, Proc. of Workshop on Computer Aided Verification, Rutgers, 1990.

[31]: Godefroid, P., Wolper, P., A Partial Approach to Model Checking, Proc. of LICS, 1991.

[32]: Hennessy, M., and Stirling, C., The Power of the Future Perfect in Program Logics, Information and Control 67, pp. 23-52, 1985.

[33]: de Nicola, R., Vaandrager, F., Three Logics for Branching Bisimulation, Proc. of LICS, 1990.

[34]: de Nicola, R., Montanari, U., and Vaandrager, F., Back and Forth Bisimulations, Proc. of CONCUR’90, 1990.

[35]: Emerson, E.A., Halpern, J.Y., Decision Procedures and Expressiveness in the Temporal Logic of Branching Time, Journal of Computer and System Sciences 30, pp. 1-24, 1985.

[36]: Courcoubetis, C., Vardi, M.Y., and Wolper, P., Reasoning about Fair Concurrent Programs, Proc. of the 18th Annual ACM Symp. on Theory on Computing, pp. 283-294, 1986.

[37]: Godefroid, P., Using Partial Orders to Improve Automatic Verification Methods, Proc. of Computer-Aided Verification Workshop, Rutgers, New Jersey, 1990.

[38]: Wolper, P., On the Relation of Programs and Computations to Models of Temporal Logic, LNCS 398, pp. 75 -123, 1987.

[39]: Kwiatkowska, M., Fairness for Non-Interleaving Concurrency, PhD Thesis, University of Leicester, 1989.

[40]: Bednarczyk, M., Categories of Asynchronous Transition Systems, Ph.d. thesis, University of Sussex, 1987.

[41]: Droste M., Concurrency, Automata and Domains, LNCS 443, pp. 195 - 208, 1990.

[42]: Stark, E.W., Concurrent Transition Systems, TCS 64, pp. 221-269, 1989.

[43]: Harel, D., Recurring Dominoes: Making the Highly Undecidable Highly Understandable, Annals of discrete mathematics, 24, pp. 51 - 72, 1985.

[44]: Parikh, R., Decidability and Undecidability in Distributed Transition Systems, A perspective in theoretical computer science, Vol. 16, 1988.

[45]: Paech, B., Concurrency as a Modality, Ph. d. thesis, Munchen University, 1991.

[46 ]: Aalbersberg I.J., Rozenberg G., Theory of traces, TCS 60, pp. 1-82, 1988.

[47]: Emerson, E.A., Halpern, J.Y., Sometimes and “Not Never” Revisited: On Branching versus Linear Time Temporal Logic, Journal of the ACM 33 (1), pp. 151-178, 1986.

205 206 P. Gastin, A. Petit Poset properties of complex trace languages 207 208 P. Gastin, A. Petit Poset properties of complex trace languages 209 210 P. Gastin, A. Petit Poset properties of complex trace languages 211 212 P. Gastin, A. Petit Poset properties of complex trace languages 213 214 P. Gastin, A. Petit Poset properties of complex trace languages 215 216 P. Gastin, A. Petit Poset properties of complex trace languages 217

Two extensions of the existing trace model

(Abstract)

Volker Diekert

Institut für Informatik Universität Stuttgart Breitwiesenstr. 20 - 22 D-7000 Stuttgart 80

April 1, 1992

The aim of this abstract is to sketch some ideas how to extend the existing trace model in two different directions. Although not done here, we would like to emphasize that both extensions could be combined from a quite general viewpoint. We will give neither proofs nor other details. This will be done in a forthcomming paper. For references we use standard references on traces, semi-traces and partial order sematics without any explicit citation. The related work can be found elsewhere.

1 Philosophy

One of the drawbacks of the existing trace model is that we are not able to express dynamic concurrency. A possible solution is to use pomsets (= partial words = labelled partial orders) for a description of a concurrent process. This enlarges of course the expressive power, but we pay this by loosing many nice algebraic and combinatorial properties of traces. so we risk to loose what make this model attractive and feasable. The original idea of Mazurkiewicz is collecting different sequential observations (or runs) into a single trace. However, this can be applied to pomsets, too.

At first glance this seems to be even a more complicated model than pomsets; but since the model becomes more abstract, we obtain in fact a simplification.

2 Formality

Our starting point is a fixed (finite) semi-dependence alphabet (Σ, D). This corresponds to the static independence relation which is known, say from the given net topology of a concurrent system. For example, if a concurrent system is specified by a Petri net (place/transition net) then we obtain a semi-dependency between transitions a and b soon as one output place of a is an input place of b. On the other hand, if a ≠ b and there is no such place, then we know that any sequential observation uabv would give rise to another possible execution ubav, or more precisely, the execution of a and b has been concurrently. (N.b. that concurrency does not mean at the same time.)

The difference between a semi-dependence relation and a dependence (without the prefix semi-) relation is simply that we do not require symmetry of D. However, we will keep the usual technical restriction that D is a reflexive relation. Given (Σ, D), the set of semi-traces is the set of finite acyclic labelled graphs [V, E, λ] where V = {1, …, n} is the set of vertices, λ : V → E is the labelling and edges are from i to j if and only if i < j and (λ(i), λ(j)) ∈ D.

Since the static dependency does not reflect the full concurrent behaviour, it may happen that in the modelized process i and j were independent, although i < j and (λ(i), λ(j)) ∈ D. Thus, we will consider the following. The objects are labelled acyclic graphs [V, E, λ] as above; but we require ony that an edge from i to j implies (λ(i), λ(j)) ∈ D and that edges are always between vertices with the same label. We call such a graph a partial trace over (Σ, D). Moreover, we identify such a graph with its induced partial order. Therefore, partial traces form a subset of those pom-sets over Σ where identically labelled vertices are totally ordered (= semi-words over Σ). However, instead of thinking of subsets, the much better viewpoint is to think of a partial trace as an equivalence class of semi-words. This equivalence is obtained by a forget operator which simply forgets the ordering between actions a and b if (a, b) ∉ D.

On the set of partial traces we have at least three useful operations. The most basic one is the concatenation or maybe better: composition. We define [V_{1}, E_{1}, λ_{1}][V_{2}, E_{2}, λ_{2}] by the disjoint union of labelled graphes with new edges from i ∈ V_{1} to j ∈ V_{2} whenever (λ(i), λ(j)) ∈ D. This defines a monoid of partial traces P (Σ, D) where the neutral element is the empty graph [∅, ∅, ∅].

The second important operation is derivation: Given a partial trace [V, E, λ] we are allowed to introduce a new edge from i to j if (λ(i), λ(j)) ∈ D and if in addition the resulting graph rests acyclic. This corresponds to a linearization operator or to a weakening of the concurrency.

The third operation is synchronization. Here we use essentially the assumption that vertices with the same label are totally ordered. We can synchronize partial traces [V_{1}, E_{1}, λ_{1}] and [V_{2}, E_{2}, λ_{2}]only if for all a ∈ λ_{1}(V_{1}) ∩ λ_{2}(V_{2}) the number of vertices with label a is equal. Then we can identify these vertices according to their ordering and we demand that the union of the graphs rests acyclic.

In order to see that the concept above is useful, assume that (Σ, D) is specified through a P/T-system. Then one can define whether a pomset over Σ is enabled and in this case its execution is defined. The basic property, which becomes crucial here, is that one can speak of an enabled partial trace since one can show that no or all representing pomsets are enabled. It is also easy to see that the set of enabled partial traces is closed with respect to derivation. Furthermore, the synchronization operator for nets corresponds to the synchronization of partial traces.

In fact, synchronization can be viewed as another motivation to generalize the semi-trace model. Indeed, contrary to traces, semi-traces are not closed with respect to synchronization. The synchronization of two semi-traces may yield a partial trace which is no semi-trace anymore. This can be seen from the following example.

[figure: (Σ, D); =; c; a; d; b]

The synchronization of the two semi-traces s_{1} = [cabd} and s_{2} = [bdca} yields the partial trace

[figure: s_{1} ∥ s_{2}; =; c; a; d; b]

The reader may verify that this is no semi-trace anymore. It is also a simple exercise to give a Petri net interpretation for this phenomenon.

3 Functoriality

In the following let us analyse some algebraic properties of partial traces. The key observation is that partial traces have a length and that one can prove Levi’s lemma. Hence by a well-known result of Christine Duboc partial traces form a free partially commutative monoid. Thus, although considering much more general objects than traces, we stay still inside the theory of free partially commutative monoids. There is only one additional difficulty. We have to consider infinitely generated monoids, in general.

Using functorial properties this can be avoided to some extent. There is an embedding of the monoid of partial traces into a finite directed product of free monoids which are generated by at most two letters, only. This can be explained as follows. First, we define a morphism between semi-dependence alphabets h : (Σ′, D′) ⟶ (Σ, D) to be a mapping h : Σ′ → Σ such that (a, b) ∈ D′ implies (h(a), h(b)) ∈ D. This yields a contra-variant functor, since h defines a monoid homomorphism h^{∗} : P (Σ, D) ⟶ P (Σ′, D′) in the following way.

Given [V, E, λ] ∈ P (Σ, D) the partial trace h^{∗}([V, E, λ]) is obtained by replacing each vertex a by the set h^{−1}(a) without any edge, (thus by a step). For a′ ∈ h^{−1}(a) and b′ ∈ h^{−1}(b) an edge is introduced if and only if (a′, b′) ∈ D′ and there has been an edge from the corresponding a to b in [V, E, λ]. The interesting fact (and main theorem on this construction) is that h^{∗} is injective if and only if h is surjective on vertices and edges.

Now, let (Σ, D) be any semi-dependence alphabet. Then (Σ, D) can be covered by the disjoint union of directed edges and some isolated points. This covering can be expressed by a surjective morphism between semi-dependence alphabets. The functorial game above then yields an embedding of P (Σ, D) into a finite directed product of monoids which are either of type P (a → b) (i.e. of type P ({a, b}, {(a, b)})) or isomorphic to a^{∗}. Thus, it is enough to have a closer look at P (a → b) for two letters a, b.

It turns out that P (a → b) is isomorphic to {a, b}^{∗}, the free monoid on two letters. The derivation becomes a semi-Thue system. Again we leave this as an exercise as well as to show that P (a − b), where the dependence relation is symmetric, is an infinitely generated free monoid. Thus, P (a − b) is definitely not isomorphic to {a, b}^{∗}

This functorial approach can be viewed as a synchronization and we obtain that any partial trace is the synchronization of a tuple of words. The translation to P/T systems yields that a process which is described by a partial trace is exactly the synchronization of certain sequences which are recorded locally at places.

4 Compositionality

For the rest of this abstract we briefly indicate a possible extension of the existing trace model to capture some aspects of non-terminating processes.

We restrict ourselves to the classical case of traces over a symmetric dependence relation D ⊆ Σ × Σ. This restriction is in fact not necessary and a more general theory over partial traces would be possible. However, since anyhow we sketch ideas only, full generality does not seem to be appropriate here.

We consider infinite (real) traces. They are approximated by their finite prefixes, or what is the same, we consider infinite directed sets (with respect to prefix ordering) of finite traces. It is well-known that a meaningfull concatenation is not possible for such objects and this led to the notion of complex trace. A (α−) complex trace is roughly a pair (r, A) where r is a real trace (i.e. a finite or infinite trace) and A is a subset of Σ. Not every set A is allowed, basically we will demand that A contains all letters which appear infinitely often in r.

The semantical idea is that the (finite) set A represents the smallest set of actions we always have to wait for before we can terminate the process r. Thus, for r infinite we have A ≠ ∅ and of course we can never terminate. However, what is possible is that if action b is independent of A then we can perform b in parallel to r after some finite time. This leads to the following calculus

(r, A)(s, B) = (r · μ_{A}(s), A ∪ B ∪ σ_{A}(s))

where μ_{A}(s) is the maximal prefix of s which is independent of A and σ_{A}(s) is the alphabet of the suffix μ_{A}(s)^{−1}s.

Using prefix ordering on complex traces we obtain a Scott domain. However, as it is known from words, the concatenation is not continuous. This is not surprising, since if r′ ≤ r and s′ ≤ s then we can not expect that r′s′ is a prefix of rs. So, in some sense it gives no information about the process rs we are interested in. The idea to solve this problem can be explained with the help of complex traces. Let us assume that we describe a process by a complex trace (r, A). What we will do is to approximate (r, A) by a sequence (r_{i}, A_{i})_{i≥1} where r_{i} ≤ r is a finite prefix and A_{i} is the alphabetic information about the future, is A_{i} = alphabet(r_{−1}r) ∩ A. Now, it is not realistic to assume that the exact information about A_{i} is available all the time (or at any time).

The question is whether we should be content with a larger or smaller set than the actual A_{i}. A first guess might be smaller. We claim that this is false for the application we have in mind. Consider simply the extreme case: without knowing explicitly that a process has terminated we should wait. Something might still happen and we should not start a second process, if it depends on the result of the first one. Thus, the solution larger is more safe. This leads to the following ordering: (r, A) ≤ (s, B) if and only if r ≤ s and (B ∪ alphabet(r^{−1}s)) ⊆ A.

This ordering looks asymmetric, but in the interpretation of the second component as wait for these possible actions, it is clear that if r is a finite process and A ⊆ B, then (r, A) is a better approximation of r than (r, B). The pair (r, ∅) is the exact information about r including the explicit information about termination.

The mathematical counterpart to this somewhat philosophical reasons to study such objects is that we obtain a complex-like domain where concatenation is continuous. In particular, if (r′, A′) ≤ (r, A), (s′, B′) ≤ (s, B) in this new ordering, then the complex product (r′μ_{A′}, (s′), A′ ∪ B′∪σ_{A′}(s′)) is a better approximation of the composed process (r, A)(s, B) than (r, A), in general.

5 Reality

Whether or not the ideas sketched above will rest a mathematical game or will lead to a useful formalism with realistic applications is open for the moment. We hopefully think that this question will have a positive answer and that this will become more clear, once this abstract will have been transformed into a complete paper.

Rational and Recognizable Complex Trace Languages^{∗}

Volker Diekert Universität Stuttgart Institut für Informatik Breitwiesenstr. 20-22 D-7000 Stuttgart 80

Paul Gastin Université Paris 6 LITP, Institut Blaise Pascal 4, place Jussieu F-75252 Paris Cedex 05

Antoine Petit Université Paris Sud LRI, URA CNRS 410 Bât. 490 F-91405 Orsay Cedex

April 1992

Abstract

Mazurkiewicz defined traces as an algebraic model of finite concurrent processes. In order to modelize non-terminating processes a good notion of infinite trace was needed, which finally led to the notion of complex trace. For complex traces an associative concatenation and an ω-iteration are defined.

This paper defines and investigates rational and recognizable complex trace languages. We prove various closure results such as the closure under boolean operations (for recognizable languages), concatenation, and left and right quotients by recognizable sets. Then we study sufficient conditions ensuring the recognizability of the finite and infinite iterations of complex trace languages. We introduce a generalization of the notion of concurrent iteration which leads to the main result of the paper: the generalization of Kleene’s and Ochmanski’s theorems to complex trace languages.

∗This research has been supported by the ESPRIT Basic Research Actions No. 3166 ASMICS and No. 3148 DEMON.

0 Introduction

The concept of traces has been introduced by A. Mazurkiewicz [Maz77] as a suitable semantics for non-sequential processes. Let us refer, for instance, surveys [Maz87, AR88, Per89] or the monograph [Die90]. Also, in these references, an extensive bibliography on the subject is given.

There are at least two possible ways to see a trace. A trace can be considered as the set of all possible sequential observations of a concurrent process. The semantics of each sequential observation is given, in a classical way, by a finite word. Hence, a trace is an equivalence class of words. From a different viewpoint, we may see a trace as a finite labeled acyclic graph where edges represent the (causal) dependency of actions. Such a graph is called a dependence graph and the semantics is that an execution has to respect the induced partial order. In this way, the process is modeled as a labeled partial order with an explicit description of concurrency.

Whatever the approach chosen, there is a natural definition of the concatenation of two traces and the set of traces forms a monoid. In fact, this monoid has been introduced and studied independently by Cartier and Foata in combinatorics [CF69].

Recognizable languages describe the behavior of finite state systems and hence form one of the basic families of a monoid. For trace monoids, this family is closed under boolean operations and concatenation, [Fli74, CP85], but it turns out that a trace language T may be recognizable whereas T^{∗} is not. The family of recognizable languages is in fact strictly included in the family of rational trace languages which is the smallest family of trace languages containing the finite languages and which is closed under union, concatenation, and star-iteration. In order to generalize Kleene’s theorem to trace languages it was then necessary to find a new operation instead of star-iteration. In a first step, Métivier and Ochmanski, [Mét86, Och85], proved independently that T^{∗} is recognizable if T is recognizable and consists of connected traces, only. This led Ochmanski to introduce a concurrent version of the star-iteration, called the c-star in the following. The c-star of T is the usual star taken over all connected components of traces in T. Replacing simply the star by the c-star operation, Ochmanski obtains the equality of recognizable and c-rational trace languages [Och85]. Let us mention that the search for sufficient conditions ensuring the recognizability of T^{∗} is an ongoing work, [Sak87, Och90, MR91].

In order to describe non-sequential processes which never terminate, e.g. distributed operating systems, the notion of infinite trace was needed. It seems that the first explicit definition of infinite traces was given by Mazurkiewicz [Maz87]. He defines an (infinite) trace as an (infinite) prefix closed directed subset of finite traces. This is the same as an (infinite) dependence graph where each vertex has finitely many predecessors only, [Maz87, Thm.13]. In the following these objects are called here real traces. At least implicitly, real traces occur already in [FR82], but a systematic study began only recently and several papers are devoted to this subject, [BMP90, Kwi90, Gas90, Gas91, GR91]. One can show that there can be no convenient associative concatenation on real traces, contrary to the set of all (say countable) dependence graphs. However, since the complement of real traces in the monoid of all dependence graphs forms an ideal, one can smash all non-real dependence graphs into a single zero element. In this way, Gastin obtains a monoid which consists of all real traces with only one additional zero element. In this monoid, rational and recognizable languages can be defined in a natural way, [Gas90]. These families are closed under the usual operations, but similarly to the case of finite traces, recognizable sets are not closed neither under star-iteration nor under ω-iteration. In [GPZ91] Gastin, Petit and Zielonka gave sufficient conditions which ensure the recognizability of T^{∗} and T^{ω}. However, substantially they used some finiteness properties due to simplifications by the concatenation with zero.

One of the main drawback of this concatenation is that a^{ω}a = 0 ≠ a^{ω}, contrary to the word case. Diekert proposed another solution to the problem of concatenation and defined the notion of complex trace [Die91]. A possible way to see a complex trace is to start with an arbitrary dependence graph. From this graph we remember in a first component its maximal real prefix and in a second component we remember those letters which depend on actions occurring either infinitely often or in the transfinite part of the graph. Thus, a complex trace is simply a real trace together with a second component which is some finite alphabetic information. Therefore, complex traces are slightly less abstract than real traces. The advantage is that the concatenation and ω-iteration are fully defined for complex traces. In particular we have a^{ω}a = a^{ω} for all letters a. Furthermore, in the special case of a full (empty respectively) dependence relation we just reobtain the usual construct of finite or infinite words (vectors respectively).

The aim of this paper is to define in a proper way rational and recognizable complex trace languages and to investigate their basic properties. We show various closure properties such as closure under boolean operations (for recognizable languages), concatenation, and left and right quotients by recognizable sets. Then we give sufficient conditions ensuring the recognizability of T^{∗} and T^{ω}. Contrary to the concatenation with zero, in the complex calculation of T^{∗} (T^{ω} respectively) an unbounded (infinite respectively) number of factors of infinite traces may be relevant. Therefore, we have to develop new techniques, which help to analyze these iterated products. In a next step we introduce the concurrent iterations c-∗ and c-ω for complex trace languages. For this we define connected components of complex traces and the c-iterations are the usual iterations over all connected components of elements of a given language. This leads to the family of c-rational complex trace languages. Our main result is the generalization of Kleene’s and Ochmanski’s theorems to complex trace languages. It states that c-rational languages are the same as recognizable languages. This result is a proper generalization of Kleene’s theorem for finite words, Büchi’s theorem for infinite words and Ochmanski’s theorem for finite traces.

The paper is organized as follows: In Section 1 we recall some definitions and facts about dependence graphs, real and complex traces, and rational and recognizable languages. The section on rational and recognizable real trace languages (Section 2) contains all basic material which is crucial for the following. This section contains new results as well as previously known results where, however, different proofs are presented in most cases. The corresponding section for complex trace languages (Section 3) generalizes the results on real traces to complex traces. In the final section (Section 4) we define connected components of complex traces and the concurrent iteration which leads to our main result.

An Extended Abstract of a preliminary version of this paper appeared at MFCS’91, [DGP91].

1 Preliminaries

1.1 Dependence graphs

Let (X, D) be a finite dependence alphabet, i.e., X is a finite alphabet with a reflexive and symmetric relation D ⊆ X × X which is called the dependence relation. The complement I = X × X \ D is called the independence relation. The quotient monoid IM(X, D) = X^{∗}/{ab = ba | (a, b) ∈ I} is the monoid of (finite) traces.

It is possible to introduce infinite traces using an equivalence relation on infinite words, the definition of infinite traces is however more natural using dependence graphs. A dependence graph (over (X, D)) is (an isomorphism class of) a labeled acyclic graph [V, E, λ] where V is a countable set of vertices, E ⊆ V × V is the set of arcs, λ : V → X is the labeling and it holds

• edges are between dependent vertices : ∀x, y ∈ V,

(λ(x), λ(y)) ∈ D ⟺ x = y or (x, y) ∈ E or (y, x) ∈ E

• the induced partial order (V, E^{∗}) is well-founded : there does not exist an infinite sequence (x_{i}) ⊆ V such that (x_{i+1}, x_{i}) ∈ E for all i.

The set of dependence graphs is denoted by G(X, D). Note that, in a dependence graph, any subset of vertices with the same label is well-ordered. This allows to think of dependence graphs by standard representation where the vertices are pairs (a, i) with a ∈ X and i is a countable ordinal. The restriction to countable sets is not essential here, we simply need any upper bound on the cardinality in order to stay inside set-theory.

For g = [V, E, λ] ∈ G(X, D) the cardinality of V is called the length of g, denoted by |g|. For U ⊆ V, let U ↓= {p ∈ V | (p, p′) ∈ E^{∗} for some p′ ∈ U} be the downward closure of U. The restriction of g to U ↓ is a dependence graph. The set of minimal elements of g is min(g) = {p ∈ V | p↓= {p}}. Since min(g) = min(g)↓, it may be viewed as a dependence graph which is finite since the alphabet is finite.

The set G(X, D) is a monoid by the concatenation [V_{1}, E_{1}, λ_{1}]·[V_{2}, E_{2}, λ_{2}] = [V, E, λ], where [V, E, λ] is the disjoint union of [V_{1}, E_{1}, λ_{1}] and [V_{2}, E_{2}, λ_{2}] together with new arcs (p_{1}, p_{2}) for all p_{1} ∈ V_{1}, p_{2} ∈ V_{2} such that (λ_{1}(p_{1}), λ_{2}(p_{2})) ∈ D. The neutral element is the empty graph 1 = [∅, ∅, ∅].

The concatenation generalizes immediately to an infinite product. Let (g_{i}) be any sequence of dependence graphs, then g = g_{1}g_{2} … ∈ G(X, D) is defined as the disjoint union of the graphs (g_{i}) with new arcs from vertices of g_{i} to vertices of g_{j} whenever i < j and the vertices have dependent labels. Thus, for any set L ⊆ G(X, D), the ω-iteration L^{ω} = {g_{1}g_{2} … | g_{i} ∈ L for i ≥ 1} ⊆ G(X, D) is defined. (In fact, we can define in the same way L^{α} for any countable ordinal α.)

Using these products, we define the canonical mapping φ from the free monoid of finite and infinite words X^{∞} into the monoid of dependence graphs G(X, D) by φ(a) = [{p}, ∅, p ↦ a] for all a ∈ X and φ(a_{1}a_{2} …) = φ(a_{1})φ(a_{2}) … for all word a_{1}a_{2} … ∈ X^{∞}. In other words, the dependence graph φ(a_{1}a_{2} …) has vertices p_{1}, p_{2}, … labeled by a_{1}, a_{2}, … and edges from p_{i} to p_{j} if and only if i < j and (a_{i}, a_{j}) ∈ D. The congruence induced by φ on X^{∗} is exactly the congruence generated by {ab = ba | (a, b) ∈ I}. Therefore, the monoid of finite traces IM(X, D) can be identified with the submonoid of finite dependence graphs and we have IM(X, D) ⊆ G(X, D).

The image φ(X^{∞}) ⊆ G(X, D) is called the set of real traces and is denoted by IR(X, D). The set of real traces can be characterized as those dependence graphs where every vertex p has a finite downward closure p↓. This is a proper subset of G(X, D).

The main disadvantage of IR(X, D) is that there is a convenient notion of concatenation only if D is transitive, i.e., when IM(X, D) = X_{1}^{∗}×⋯×X_{k}^{∗} is a direct product of free monoids. In this case, IR(X, D) = X_{1}^{∞}×⋯×X_{k}^{∞}. However, even in this case, the concatenation will be different from the (natural) concatenation of G(X, D). In fact, (for X ≠ ∅) the set IR(X, D) is never a submonoid of G(X, D). Consider any pair (a, b) ∈ D. Then a^{ω}b ∈ G(X, D) is not real, since the vertex with label b depends on infinitely many vertices. In particular, the canonical mapping φ : X^{∞} → G(X, D) is not a morphism. It neither commutes with the concatenation nor with the ω-iteration, in general. More precisely, let L, K ⊆ X^{∞} then we have φ(L·K) ≠ φ(L)·φ(K) and φ(L^{ω}) ≠ φ(L)^{ω} as soon as L contains an infinite word and K contains a nonempty word.

1.2 Complex traces

Every dependence graph g = [V, E, λ] ∈ G(X, D) splits into its real part Re(g) = {p ∈ V | p↓ is finite} and its transfinite part Tr(g) = {p ∈ V | p↓ is infinite}. Of course, Re(g), Tr(g) are viewed as dependence graphs by restricting E and λ correspondingly. Note that for all g ∈ G(X, D) it holds g = Re(g) · Tr(g). The mapping Re : G(X, D) → IR(X, D) does not define a congruence of G(X, D). However, we can define the coarsest congruence of G(X, D) such that any two congruent dependence graphs g and g′ verify Re(g) = Re(g′). Dependence graphs falling in the same congruence class are called practically undistinguishable and the quotient of G(X, D) by this congruence is the monoid of complex traces C(X, D), [Die91].

In order to give an explicit description of C(X, D) we need a few more notations. For a dependence graph g ∈ G(X, D) the alphabet of g, denoted by alph(g), is the set λ^{−1}(V). Hence, alph(g) is the set of letters occurring in g. The alphabet at infinity of g denoted by alphinf(g), is the set of letters occurring infinitely often in g together with alph(Tr(g)). For a subset A ⊆ X we denote the set of letters depending on A by D(A) = {b ∈ X | ∃a ∈ A : (a, b) ∈ D}, and the set of letters independent of A by I(A) = X \ D(A) = {b ∈ X | ∀a ∈ A : (a, b) ∈ I}. Finally, for a dependence graph g ∈ G(X, D), we define its imaginary part Im(g) by Im(g) = D(alphinf(g)).

Using these notations, the coarsest congruence of G(X, D) which respects real parts admits the following characterization. Two dependence graphs g and g′ are congruent (or practically undistinguishable) if and only if Re(g) = Re(g′) and Im(g) = Im(g′). Therefore, a complex trace is a pair (Re(g), Im(g)) for some dependence graph g ∈ G(X, D). Often, we denote a complex trace by (r, D(A)) where r ∈ IR(X, D) and A ⊆ X. Note that the real part r is uniquely defined by the complex trace whereas the subset A ⊆ X is not known, in general. (It is only D(A) which is given by the complex trace.)

The concatenation of C(X, D) is inherited from G(X, D), but of course it is convenient to have an explicit formula. For this purpose, we introduce the μ-notation. Let g ∈ G(X, D) be a dependence graph and A ⊆ X be any subset. Then μ_{A}(g) ∈ IR(X, D) is the maximal real prefix of g containing letters from I(A), only. Thus, for g = [V, E, λ], the prefix μ_{A}(g) is the restriction of g to {p ∈ V | p ↓ is finite and alph(p↓) ⊆ I(A)}. Note that, for g ∈ G(X, D) and A ⊆ X, we have μ_{A}(g) = μ_{A}(Re(g)). Hence the μ-notation is also well-defined for complex traces. Since G(X, D) is left-cancellative, [Die91], there is a unique dependence graph Suff_{A}(g) such that g = μ_{A}(g) · Suff_{A}(g). With these notations the concatenation in C(X, D) becomes [Die91]:

(r, D(A)) · (s, D(B)) = (r · μ_{A}(s), D(A ∪ B ∪ alph(Suff_{A}(s))))

This formula is of first importance for the calculus on complex traces and will be used throughout.

It turns out that the coarsest congruence on G(X, D) which respects real parts is also a “congruence” for the ω-product on G(X, D). Therefore, the ω-iteration L^{ω} of a complex trace language L is well-defined. Note that, following the general definition of the ω-product for dependence graphs, we have L^{ω} = L^{∗} ∪ (L \ {1})^{ω} if 1 ∈ L.

In the remainder, we identify a real trace r with the complex trace (r, D(alphinf(r))) = (r, Im(r)). Thus, we have IM(X, D) ⊆ IR(X, D) ⊆ C(X, D) and C(X, D) is a quotient monoid of G(X, D). For a subset A ⊆ X and a language L ⊆ C(X, D) (L ⊆ IR(X, D) respectively, L ⊆ G(X, D) respectively) we define L_{A} = {x ∈ L | Im(x) = D(A)}. Note that IR(X, D)_{∅} = C(X, D)_{∅} = G(X, D)_{∅} = IM(X, D). A language L is called finitary if L = L_{∅}, i.e., L ⊆ IM(X, D).

The link between real and complex trace languages can be done using concatenations by finite shift-traces. A finite trace s_{A,B} is called a shift trace from D(A) to D(B) if for some complex trace (r, D(A)) we have (r, D(A)) · s_{A,B} = (r, D(B)). In this case, we have (t, D(A)) · s_{A,B} = (t, D(B)) for all complex traces (t, D(A)). A shift trace s_{A,B} satisfies μ_{A}(s_{A,B}) = 1 (i.e., min(s_{A,B}) ⊆ D(A) and D(A ∪ alph(s_{A,B})) = D(B)). Shift traces from D(A) to D(B) do not exist for all pairs (A, B). The necessary and sufficient condition is that there exists a sequence of letters a_{1}, …, a_{k} such that a_{i} ∈ D(A ∪ {a_{1}, …, a_{i−1}}) for 1 ≤ i ≤ k and D(B) = D(A ∪ {a_{1}, …, a_{k}}). We simply write A shift B in this case. If A shift B then some shift trace s_{A,B} can be chosen of length at most |D(B)|.

It is easy to see that every complex trace language L ⊆ C(X, D) can be written as a finite union of real trace languages concatenated by shift traces:

L = ⋃_{A shift B}(Re(L_{B}) ∩ IR(X, D)_{A}) · s_{A,B}  (3)

Let us point out that the word monoid X^{∞} with right-absorbent concatenation x·y = x for x ∈ X^{ω} is just the special case of the complex trace monoid C(X, D) for a full dependence relation D = X × X. In fact, if the independence relation is empty then the imaginary part is redundant. For a word x we have Im(x) = ∅ if x is finite and Im(x) = X otherwise (i.e., if x is an infinite word). Furthermore, the partition X^{∞} = X^{∗} ∪ X^{ω} is the partition of X^{∞} into (X^{∞})_{∅} and (X^{∞})_{X}.

In the remainder, we will study rational and recognizable complex trace languages. As it becomes clear from Equation (3), the overall strategy is to transfer results from real trace languages. Since IR(X, D) = φ(X^{∞}), a basic technique used here to obtain results on real traces is to work with representing words. The next section briefly recalls some well-known properties of word languages.

1.3 Regular languages

We have (at least) two possibilities to define regular subsets of the monoid of finite and infinite words X^{∞}. We can use either rational expressions or finite state acceptors. This leads to the families of rational and recognizable languages respectively.

The family of rational word languages, Rat(X^{∞}), is defined as the smallest family of subsets of X^{∞} which contains all finite languages of finite words and which is closed under the operations union, concatenation, ∗-iteration, and ω-iteration. From the definition of the concatenation in X^{∞}, it is clear that we may restrict the operations of concatenation L · K, of Kleene-∗ L^{∗}, and of ω-iteration L^{ω} to the case of finitary languages L ⊆ X^{∗}. Thus, we are never forced to use the right-absorbent concatenation x · y = x with x ∈ X^{ω}.

We define recognizable word languages using non-deterministic Büchi automata. There are several equivalent possibilities to give acceptance conditions. For technical reasons we use here acceptance by transitions. This allows in particular to construct automata which accept languages from X^{∞} without separation of the finitary part. Moreover, this acceptance type is very convenient for our purposes since from the set of transitions which occur infinitely often in a path, we can deduce directly the alphabet at infinity of its label. To be precise, we define a Büchi automaton to be a tuple (Q, δ, q_{0}, Δ) where Q is the finite set of states, δ ⊆ Q × (X ∪ {1}) × Q is a finite set of labeled arcs called transitions, q_{0} ∈ Q is the initial state, and Δ ⊆ δ is the set of final transitions. An infinite path is a sequence q_{0}, x_{1}, q_{1}, x_{2}, q_{2}, … where (q_{i−1}, x_{i}, q_{i}) ∈ δ for all i > 0 and its label is the word x_{1}x_{2} ⋯ ∈ X^{∞}. A finite or infinite word x is accepted if there exists an infinite path labeled by x, starting in q_{0} and repeating some transition from Δ infinitely often. Note that, finite words can be accepted by infinite loops of 1-transitions. A language L ⊆ X^{∞} is called recognizable if it is accepted by some Büchi automaton.

Another equivalent definition for recognizable languages is to use recognizing morphisms. Let η : X^{∗} → S be a morphism to a finite monoid S. We say that η recognizes a language L ⊆ X^{∞} if for any finite or infinite sequence (x_{i}) ⊆ X^{∗}, we have x_{1}x_{2} … ∈ L implies η^{−1}η(x_{1})η^{−1}η(x_{2}) … ⊆ L. Using Ramsey factorization, one can show that any recognizable language can be written as a finite union

L = ⋃_{(s,e)∈P} X_{s}X_{e}^{ω}  (4)

where X_{s} = η^{−1}(s), X_{e} = η^{−1}(e) and P = {(s, e) ∈ S × S | se = s, e^{2} = e, X_{s}X_{e}^{ω} ∩ L ≠ ∅}.

Büchi’s classical theorem asserts that for X^{∞} the families of rational languages and of recognizable languages coincide. We can therefore use the term regular languages without any ambiguity if it refers to word languages which are rational (recognizable respectively.) A detailed study of regular word languages can be found in [PP91].

1.4 Ramsey factorization

Let η : M ⟶ S be a morphism from an arbitrary monoid M to a finite monoid S and let u_{0}, u_{1}, … be an infinite sequence of elements of M. There exist an infinite increasing sequence of integers i_{0} < i_{1} < … and s, e ∈ S such that se = s, e^{2} = e, η(u_{0} … u_{i_{0}}) = s and η(u_{1+i_{j}} … u_{i_{k}}) = e for all 0 ≤ j < k. This is called a Ramsey factorization of the infinite sequence u_{0}, u_{1}, ….

The existence of a Ramsey factorization is one of the fundamental principles used in this paper. A simple and direct proof of this result can be found in [PP91]. It is also a trivial application of Ramsey’s Theorem [Gra81].

2 Rational and recognizable real trace languages

Recall that in a general monoid M, the family Rat(M) is the least family which contains the finite sets and which is closed under union, product and Kleene’s iteration. This definition applies in particular for the free monoid X^{∗} and the finitary trace monoid IM(X, D). In order to define the family Rat(X^{∞}), we start with finite sets of finite words and the closure under ω-iteration is required, too. Since there is no concatenation defined for real traces in general, we use restricted operations, only.

Definition: The family of rational real trace languages, Rat(IR(X, D)), is the smallest family satisfying the following conditions:

i) Every finite set of finite traces is rational.

ii) If K, L ⊆ IR(X, D) are rational, then the union K ∪ L is rational.

iii) If K, L ⊆ IR(X, D) are rational and if in addition K ⊆ IM(X, D), then K · L, K^{∗}, and K^{ω} are rational.

This definition is consistent with the definitions of Rat(X^{∞}) and Rat(IM(X, D)) since Rat(IR(X, D)) = Rat(X^{∞}) when D = X × X is the full dependence relation and for L ⊆ IM(X, D) we have L ∈ Rat(IR(X, D)) if and only if L ∈ Rat(IM(X, D)).

Note that the canonical mapping φ : X^{∞} → IR(X, D) commutes with these restricted operations. This is used in the next proposition which gives several equivalent characterizations of the family Rat(IR(X, D)).

Proposition 2.1 Let L ⊆ IR(X, D) be any real trace language. Then the following assertions are equivalent.

i) The language L is rational, i.e., L ∈ Rat(IR(X, D))

ii) The language L is the image of a regular word language, i.e., L = φ(L′) for some L′ ∈ Rat(X^{∞}).

iii) The language L can be written as a finite union

L = ⋃_{1≤i≤k} M_{i}N_{i}^{ω}

where M_{i}, N_{i} are finitary rational trace languages for all 1 ≤ i ≤ k.

Proof: i) ⇒ ii): First, assume that L is a finite set of finite traces. We have L = φ(φ^{−1}(L)) and φ^{−1}(L) is rational since it is finite. Now, for K′, L′ ⊆ X^{∞} we have φ(K′ ∪ L′) = φ(K′) ∪ φ(L′) and if moreover K′ ⊆ X^{∗} then φ(K′ · L′) = φ(K′) · φ(L′), φ(K^{′∗}) = φ(K′)^{∗} and φ(K^{′ω}) = φ(K′)^{ω}. Therefore, the result follows by induction on the rational expression defining L. ii) ⇒ iii): Using Equation (4) we obtain L′ = ⋃_{1≤i≤k} M′_{i} · N_{i}^{′ω} where M′_{i}, N′_{i} ∈ Rat(X^{∗}) for 1 ≤ i ≤ k. Since φ commutes with these operations, we obtain L = ⋃_{1≤i≤k} φ(M′_{i}) · φ(N′_{i})^{ω}. Using again the same property of φ we deduce that the languages φ(M′_{i}), φ(N′_{i}) are finitary rational trace languages, which concludes this part. iii) ⇒ i): trivial. □

Recall that we have defined recognizable word languages by Büchi automata. In order to define recognizable real trace languages we will consider automata which accept closed languages. A word language L ⊆ X^{∞} is said to be closed (with respect to (X, D)) if L = φ^{−1}φ(L) for the canonical mapping φ : X^{∞} → IR(X, D). If a Büchi automaton accepts a closed language then there is no ambiguity in saying which real traces are accepted. Moreover we will see that it is decidable whether a Büchi automaton accepts a closed language or not. This approach leads to the following definition.

Definition: A language L ⊆ IR(X, D) is called recognizable if φ^{−1}(L) is a (closed) regular word language. The family of recognizable real trace languages is denoted by Rec(IR(X, D)).

Remark 2.2 Since the family Rec(X^{∞}) is a boolean algebra, it follows directly from this definition that the family of recognizable real trace languages forms a boolean algebra, too. It is closed under union, intersection, and complementation.

Another possible way to define recognizable languages is, exactly as in the word case, by recognizing morphisms. Let η : IM(X, D) → S be a morphism to a finite monoid S. We say that η recognizes a language L ⊆ IR(X, D), if for any finite or infinite sequence (x_{i}) ⊆ IM(X, D), x_{1}x_{2} … ∈ L implies η^{−1}η(x_{1})η^{−1}η(x_{2}) … ⊆ L. We could also use the generalization to trace languages of the syntactic congruence defined by Arnold for word languages [Arn85]. Given L ⊆ IR(X, D), two finite traces x, y are syntactically congruent if and only if:

\begin{aligned}∀u, v ∈ IM(X, D) & : & u(xv)^{ω} ∈ L ⇔ u(yv)^{ω} ∈ L \\ ∀u, v, w ∈ IM(X, D) & : & uxvw^{ω} ∈ L ⇔ uyvw^{ω} ∈ L \end{aligned}

We denote the syntactic congruence of L by ≡_{L} and we obtain a canonical morphism η_{L} : IM(X, D) → IM(X, D)/ ≡_{L}. In general, neither IM(X, D)/ ≡_{L} is finite nor does η_{L} recognize L. This is true however if L is recognizable. We have the following proposition, stating that all approaches are equivalent.

Proposition 2.3 ([Gas91]) A language L ⊆ IR(X, D) is recognizable if and only if any of the following equivalent definitions is satisfied.

i) The language L is the image of a closed regular word language.

ii) There exists a morphism η form IM(X, D) to a finite monoid S recognizing L.

iii) The syntactic congruence ≡_{L} is of finite index in IM(X, D) and the syntactic morphism η_{L} recognizes L.

From Propositions 2.1 and 2.3, it is clear that every recognizable language is rational. The converse holds for strings by Büchi’s Theorem. However, as soon as there is a pair (a, b) ∈ I of independent letters, we find a finitary rational language, e.g., L = φ(ab)^{∗} ⊆ IM(X, D), which is rational but not recognizable (since φ^{−1}(L) = {w ∈ {a, b}^{∗} | |w|_{a} = |w|_{b}} is not a recognizable word language).

An example of an ω-language L ⊆ IR(X, D) \ IM(X, D) which is rational but not recognizable, can be constructed on three letters, say a, b, c where there is at least one pair of independent letters, say (a, b) ∈ I. Then the rational language L = φ(ab)^{∗} · φ(c)^{ω} is not recognizable since the projection of φ^{−1}(L) to {a, b}^{∞} is {w ∈ {a, b}^{∗} | |w|_{a} = |w|_{b}}.

We leave it as an exercise to the reader to show that no such two letters example exists.

Rational trace languages are not closed under intersection, in gen-

eral. For example, let (X, D) = a  b  c then φ(ab)^{∗}φ(c)^{∗} ∩

φ(b)^{∗}φ(ac)^{∗} = {φ(a^{n}b^{n}c^{n}) | n ≥ 0}, which is not rational since the projection to {b, c}^{∗} yields the non rational language {b^{n}c^{n} | n ≥ 0} ⊆ {b, c}^{∗}. However we have the following observation. It is stated as a lemma since we will use it throughout.

Lemma 2.4 Let K ⊆ IR(X, D) be rational and L ⊆ IR(X, D) be recognizable. Then the intersection K ∩ L is rational.

Proof: Let K′, L′ ⊆ X^{∞} be regular word languages such that φ(K′) = K, φ(L′) = L and L′ is closed. Then K′ ∩ L′ is a regular word language and we have φ(K′ ∩ L′) = K ∩ L. Hence, by Proposition 2.1, K ∩ L is rational. □

The following combinatorial lemma becomes important below.

Lemma 2.5 Let t = t_{1}t_{2} …, z = z_{1}z_{2} … ∈ X^{∞} be two factorizations for t, z ∈ X^{∞} with t_{i}, z_{i} ∈ X^{∗}. Then we have φ(t) = φ(z) ∈ IR(X, D) if and only if there are sequences of integers 0 = m_{0} < m_{1} < m_{2} < …, 0 = n_{0} < n_{1} < n_{2} < …, and finite words 1 = y_{0}, x_{1}, y_{1}, x_{2}, y_{2}, … ∈ X^{∗} such that it holds for all i ≥ 1:

\begin{aligned}φ(y_{i−1}x_{i}) & = & φ(t_{1+m_{i−1}} … t_{m_{i}}) \\ φ(x_{i}y_{i}) & = & φ(z_{1+n_{i−1}} … z_{n_{i}}) \end{aligned}

A rough picture of the situation described in the lemma above is given in the following picture.

φ(t) = φ(t_{1} ⋯ t_{m_{1}}) φ(t_{1+m_{1}} ⋯ t_{m_{2}}) φ(t_{1+m_{2}} ⋯ t_{m_{3}}) …
=  φ(x_{1})  φ(y_{1}x_{2})  φ(y_{2}x_{3})  …
= φ(x_{1}y_{1})  φ(x_{2}y_{2})  φ(x_{3}y_{3})  …
= φ(z_{1} ⋯ z_{n_{1}}) φ(z_{1+n_{1}} ⋯ z_{n_{2}}) φ(z_{1+n_{2}} ⋯ z_{n_{3}}) …
=  φ(z)

Double factorization of two words representing the same real trace

Proof: It is clear that the conditions imply φ(t) = φ(y_{0}x_{1}y_{1}x_{2}y_{2} …) = φ(z). Therefore it is enough to show the other direction and we may assume φ(t) = φ(z). Let y_{0} = 1, x_{1} = t_{1} and m_{1} = 1. Then we may assume by induction that for some k ≥ 1 we found indices 0 = m_{0} < … < m_{k} and 0 = n_{0} < … < n_{k−1} and finite words 1 = y_{0}, x_{1}, …, y_{k−1}, x_{k} such that

\begin{aligned}φ(y_{i−1}x_{i}) & = & φ(t_{1+m_{i−1}} … t_{m_{i}}) & for 1 ≤ i ≤ k \\ φ(x_{i}y_{i}) & = & φ(z_{1+n_{i−1}} … z_{n_{i}}) & for 1 ≤ i ≤ k − 1. \end{aligned}

Since φ(y_{0}x_{1} … y_{k−1}x_{k}) is a finite prefix of φ(t) = φ(z) and φ(y_{0}x_{1} … x_{k−1}y_{k−1}) = φ(z_{1} … z_{n_{k−1}}) it follows from the left-cancellativity of IR(X, D) that φ(x_{k}) is a finite prefix of φ(z_{1+n_{k−1}}z_{2+n_{k−1}} …). Hence we find some n_{k} > n_{k−1} such that φ(x_{k}) is a prefix of φ(z_{1+n_{k−1}} … z_{n_{k}}), i.e., φ(x_{k}y_{k}) = φ(z_{1+n_{k−1}} … z_{n_{k}}) for some y_{k} ∈ X^{∗}. A symmetric argument yields that for some m_{k+1} > m_{k} there exists x_{k+1} ∈ X^{∗} such that φ(y_{k}x_{k+1}) = φ(t_{1+m_{k}} … t_{m_{k+1}}). This concludes the proof of the lemma. □

A first application of the lemma above shows that it is decidable whether a regular word language is closed by computing its syntactic congruence. If a language L ⊆ X^{∞} is closed, then obviously its syntactic congruence ≡_{L} verifies ab ≡_{L} ba for all (a, b) ∈ I. The converse is easy for finitary languages. The next theorem states that the converse is true, in general. The decidability result follows since the syntactic congruence of a regular word language is computable [PP91].

Theorem 2.6 A regular language L ⊆ X^{∞} is closed (i.e., L = φ^{−1}φ(L)) if and only if we have ab ≡_{L} ba for all (a, b) ∈ I.

Proof: We have to show that ab ≡_{L} ba for all (a, b) ∈ I implies L = φ^{−1}φ(L). Let t ∈ L and z ∈ X^{∞} such that φ(t) = φ(z). Applying Lemma 2.5 to the trivial factorizations t = a_{1}a_{2} … and z = b_{1}b_{2} … with a_{i}, b_{i} ∈ X ∪ {1}, we find two new factorizations t = t_{1}t_{2} … and z = z_{1}z_{2} … with t_{i}, z_{i} ∈ X^{∗} and a sequence of finite words 1 = y_{0}, x_{1}, y_{1}, x_{2}, y_{2}, … ∈ X^{∗} such that φ(y_{i−1}x_{i}) = φ(t_{i}) and φ(x_{i}y_{i}) = φ(z_{i}) for i ≥ 1.

Let η_{L} : X^{∗} → X^{∗}/ ≡_{L} be the syntactic morphism of L. Since ab ≡_{L} ba for all (a, b) ∈ I we have η(t_{i}) = η(y_{i−1}x_{i}) for i ≥ 1. Since η recognizes L this implies y_{0}x_{1}y_{1}x_{2} … ∈ L. In the same way, η(z_{i}) = η(x_{i}y_{i}) for i ≥ 1, whence z ∈ L. □

However, the main interest in Lemma 2.5 results from the fact that it yields a simplified proof for the following result.

Theorem 2.7 ([GPZ91]) Let L ⊆ IM(X, D) be a finitary recognizable trace language such that L = L^{+}. Then L^{ω} ⊆ IR(X, D) is recognizable, too.

Proof: Let (Q, δ, q_{0}, F) be a classical finite deterministic word automaton recognizing φ^{−1}(L) by final states, i.e., F ⊆ Q and a finite path is accepted if its initial state is q_{0} and its final state is in F.

We now construct a Büchi automaton recognizing φ^{−1}(L^{ω}) as follows. The set of states is Q × Q × P(X) and the initial state is (q_{0}, q_{0}, ∅). For each letter a ∈ X and state (q, q′, A) ∈ Q × Q × P(X) we define the transition

(q, q′, A) ⟶^{a} (q, δ(q′, a), A ∪ {a})

and if a ∈ I(A) then additionally another transition

(q, q′, A) ⟶^{a} (δ(q, a), q′, A)

Furthermore, if q ∈ F, we add a final 1-transition:

(q, q′, A) ⟶^{1} (q′, q_{0}, ∅).

Such a non-deterministic jump signifies that a member of φ^{−1}(L) has been computed in the first component.

Note that, if we have a path (p, p′, A) ⟶^{∗}^{z} (q, q′, B) without 1transition in this automaton then there exist x, y ∈ X^{∗} such that φ(z) = φ(xy), q = δ(p, x), q′ = δ(p′, y) and B = A ∪ alph(y). (The converse is trivially true.)

According to the definition of Section 1.3 this automaton accepts all finite or infinite words which are labelings of infinite paths using infinitely many final 1-transitions. By definition, the accepted language is recognizable. Thus, we have to show only that the accepted language is φ^{−1}(L^{ω}).

First, let z ∈ X^{∞} be an accepted word. Marking the final transitions in its accepted path, we obtain the factorization:

(q_{0}, q_{0}, ∅) ⟶^{∗}^{z_{1}} (q_{1}, q′_{1}, A_{1})
⟶^{1} (q′_{1}, q_{0}, ∅) ⟶^{∗}^{z_{2}} (q_{2}, q′_{2}, A_{2})
⟶^{1} (q′_{2}, q_{0}, ∅) ⟶^{∗}^{z_{3}} …

with z = z_{1}z_{2}z_{3} . . ..

Using the remark above, we find a sequence or finite words x_{1}, y_{1}, x_{2}, y_{2}, … ∈ X^{∗} such that, with q′_{0} = q_{0}, we have φ(z_{i}) = φ(x_{i}y_{i}), q_{i} = δ(q′_{i−1}, x_{i}) and q′_{i} = δ(q_{0}, y_{i}) for all i ≥ 1. Thus, with y_{0} = 1, we obtain for all i ≥ 1 δ(q_{0}, y_{i−1}x_{i}) = q_{i} ∈ F, i.e., y_{i−1}x_{i} ∈ φ^{−1}(L). Hence, we have φ(z) = φ(x_{1}y_{1})φ(x_{2}y_{2}) … = φ(y_{0}x_{1})φ(y_{1}x_{2}) … ∈ L^{ω}.

For the other direction let z = b_{1}b_{2} … ∈ X^{∞} be any word in φ^{−1}(L^{ω}). Then we have φ(z) = φ(t) for some t = t_{1}t_{2} … ∈ X^{∞} with t_{i} ∈ φ^{−1}(L) for all i ≥ 1. Using Lemma 2.5, we obtain a sequence of finite words 1 = y_{0}, x_{1}, y_{1}, x_{2}, y_{2}, … ∈ X^{∗} and two factorizations z = z_{1}z_{2} … and t = (t_{1} … t_{m_{1}})(t_{1+m_{1}} … t_{m_{2}}) … such that for all i ≥ 1 we have

φ(z_{i}) = φ(x_{i}y_{i}) and φ(y_{i−1}x_{i}) = φ(t_{1+m_{i−1}} … t_{m_{i}}) ∈ L^{∗} = L

Therefore, we find an accepting path for z as follows:

(q_{0}, q_{0}, ∅)  ⟶^{∗}^{z_{1}} (δ(q_{0}, x_{1}), δ(q_{0}, y_{1}), alph(y_{1}))
⟶^{1} (δ(q_{0}, y_{1}), q_{0}, ∅) ⟶^{∗}^{z_{2}} (δ(q_{0}, y_{1}x_{2}), δ(q_{0}, y_{2}), alph(y_{2}))
⟶^{1} (δ(q_{0}, y_{2}), q_{0}, ∅) ⟶^{∗}^{z_{3}} …

□

The main application of the theorem above is when L is connected. A finite trace is called connected if it is connected as a dependence graph or what is the same if its alphabet induces a connected subgraph of (X, D). A finitary language is called connected if all its elements are connected. Due to independent works by Métivier [Mét86] and Ochmanski [Och85], it is known that L^{∗} (and hence L^{+}) is recognizable if L is recognizable and connected. Therefore we have the following corollary.

Corollary 2.8 Let L ⊆ IM(X, D) be recognizable and connected. Then L^{ω} is recognizable.

Proof: We have L^{ω} = (L^{+})^{ω}. □

Note that in G(X, D) the concatenation xy of two real traces is real if and only if alphinf(x) × alph(y) ⊆ I. Therefore, even if the concatenation K · L, as a rational operation on real trace languages, has been defined only when K is finitary, it can clearly be extended to the case where alphinf(x) × alph(y) ⊆ I for all x ∈ K and y ∈ L. The reason that the rational operation was defined in a more restricted way was to maintain commutation with the canonical mapping φ : X^{∞} → IR(X, D). This property is not important for the closure under concatenation of Rec(IR(X, D)). It was proved by Gastin [Gas91] that the family of recognizable real trace languages is closed under this extension of the real concatenation. The key to the proof of this result is the following lemma which introduces the I-shuffle and for which we give a new proof using non-deterministic Büchi automata.

For the sake of simplicity, we write (x, y) ∈ I if two words or real traces x and y are fully independent, i.e., if alph(x) × alph(y) ⊆ I.

Lemma 2.9 Let K′, L′ ⊆ X^{∞} be regular. Then the following I-shuffle is regular, too.

K′ ⊔⊔_{I} L′ = {u_{1}v_{1}u_{2}v_{2} … ∈ X^{∞} |
u_{1}u_{2} … ∈ K′, v_{1}v_{2} … ∈ L′ and (v_{i}, u_{j}) ∈ I for all i < j}

Proof: For i = 1, 2, let A_{i} = (Q_{i}, δ_{i}, q_{i,0}, Δ_{i}) be Büchi automata accepting K′ and L′ respectively. We may assume that for i = 1, 2, (q_{i}, 1, q_{i}) ∈ δ_{i} for all q_{i} ∈ Q_{i}. We construct an automaton A for K′⊔⊔_{I} L′ as follows. The set of states is Q_{1} × Q_{2} × P(X) × P({1, 2}) and the initial state is (q_{1,0}, q_{2,0}, ∅, ∅). We define simultaneously the transitions of A and their projections on A_{1} and A_{2}.

• If t_{1} = (q_{1}, x, q′_{1}) ∈ δ_{1} and alph(x) × A ⊆ I then

(q_{1}, q_{2}, A, B) ⟶^{x} (q′_{1}, q_{2}, A, B′)

with B′ = B ∪ {1} if t_{1} ∈ Δ_{1} and B′ = B otherwise.

Moreover, the projections of this transition are t_{1} and (q_{2}, 1, q_{2}) respectively.

• If t_{2} = (q_{2}, x, q′_{2}) ∈ δ_{2} then

(q_{1}, q_{2}, A, B) ⟶^{x} (q_{1}, q′_{2}, A ∪ alph(x), B′)

with B′ = B ∪ {2} if t_{2} ∈ Δ_{2} and B′ = B otherwise.

Moreover, the projections of this transition are (q_{1}, 1, q_{1}) and t_{2} respectively.

• Finally, we add the final 1-transitions

(q_{1}, q_{2}, A, {1, 2}) ⟶^{1} (q_{1}, q_{2}, A, ∅)

whose projections are (q_{1}, 1, q_{1}) and (q_{2}, 1, q_{2}) respectively.

Let us show that the language accepted by this automaton is K′ ⊔⊔_{I} L′. Let P be an accepted path of A with label w. Clearly, the projections P_{1} and P_{2} of P are paths of A_{1} and A_{2}. Let u and v be the labels of P_{1} and P_{2}. From the definition of the transitions, we can easily verify that w ∈ u ⊔⊔_{I} v. Moreover, between two final transitions of P there must be at least one final transition in the corresponding parts of P_{1} and P_{2}. Therefore, P_{1} and P_{2} are accepted paths and w ∈ K′ ⊔⊔_{I} L′.

Conversely, let w ∈ K′ ⊔⊔_{I} L′. We have w = u_{1}v_{1}u_{2}v_{2} … with u = u_{1}u_{2} … ∈ K′, v = v_{1}v_{2} … ∈ L′ and (v_{i}, u_{j}) ∈ I for all i < j. Let

q_{1,0} = p_{0} ⟶^{∗}^{u_{1}} p_{1} ⟶^{∗}^{u_{2}} p_{2} ⟶^{∗}^{u_{3}} p_{3} …

be an accepting path in A_{1} for u and let

q_{2,0} = q_{0} ⟶^{∗}^{v_{1}} q_{1} ⟶^{∗}^{v_{2}} q_{2} ⟶^{∗}^{v_{3}} q_{3} …

be an accepting path in A_{2} for v. We construct an accepting path for w in A as follows:

(p_{0}, q_{0}, ∅, ∅)  ⟶^{∗}^{u_{1}} (p_{1}, q_{0}, ∅, B_{1})
⟶^{∗}^{v_{1}} (p_{1}, q_{1}, alph(v_{1}), B′_{1})  ⟶^{1} (p_{1}, q_{1}, alph(v_{1}), B′′_{1})
⟶^{∗}^{u_{2}} (p_{2}, q_{1}, alph(v_{1}), B_{2})  ⟶^{∗}^{v_{2}} (p_{2}, q_{2}, alph(v_{1}v_{2}), B′_{2})
⟶^{1} (p_{2}, q_{2}, alph(v_{1}v_{2}), B′′_{2}) ⟶^{∗}^{u_{3}} (p_{3}, q_{2}, alph(v_{1}v_{2}), B_{3})
⟶^{∗}^{v_{3}} …

with for all i ≥ 1, B′′_{i} = ∅ if B′_{i} = {1, 2} and B′′_{i} = B′_{i} otherwise. □

Proposition 2.10 ([Gas91]) Let K, L ⊆ IR(X, D) be recognizable (rational respectively) real trace languages such that for all x ∈ K, y ∈ L it holds alphinf(x) × alph(y) ⊆ I. Then K · L is recognizable (rational respectively).

Proof: Consider the canonical mapping φ : X^{∞} → IR(X, D). First, observe that for u, v ∈ X^{∞}, u⊔⊔_{I}v is not empty if and only if alphinf(u)× alph(v) ⊆ I. Moreover, in this case, φ(w) = φ(u)·φ(v) for all w ∈ u⊔⊔_{I}v. Now, there exist regular languages K′, L′ ⊆ X^{∞} such that φ(K′) = K and φ(L′) = L. By the observation above, we have φ(K′ ⊔⊔_{I} L′) = K ·L. Hence, by Lemma 2.9 and Proposition 2.1, K · L is rational.

Finally, if K and L are recognizable, we may assume that K′ = φ^{−1}(K) and L′ = φ^{−1}(L) are closed (Proposition 2.3). We claim that in this case, K′ ⊔⊔_{I} L′ is closed too, i.e., K′ ⊔⊔_{I} L′ = φ^{−1}(K · L), which proves that K · L is recognizable.

Let w ∈ φ^{−1}φ(K′ ⊔⊔_{I} L′) = φ^{−1}(K · L) then φ(w) = x · y for some x ∈ K and y ∈ L. We denote by w_{i} the i-th letter of w or 1 if |w| < i. For a letter a and a word (or a real trace) x we denote by |x|_{a} the number of occurrences of a in x. We construct two sequences u_{1}, v_{1}, u_{2}, v_{2}, … ∈ X ∪ {1} as follows: u_{i} = w_{i}, v_{i} = 1 if |x|_{w_{i}} ≥ |w_{1} … w_{i}|_{w_{i}} and u_{i} = 1, v_{i} = w_{i} otherwise.

Clearly, w = u_{1}v_{1}u_{2}v_{2} . . .. Let u = u_{1}u_{2} … and v = v_{1}v_{2} . . .. From φ(w) = x · y we deduce that φ(u) = x, φ(v) = y and (v_{i}, u_{j}) ∈ I for all i < j. Hence, u ∈ φ^{−1}(K) = K′, v ∈ φ^{−1}(L) = L′ and w ∈ K′ ⊔⊔_{I} L′ which proves the claim. □

Remark that Proposition 2.10 states that the family Rat(IR(X, D)) is closed under this extended concatenation. Hence, we may have replaced the concatenation restricted to finitary languages on the left by this extended one without changing the family Rat(IR(X, D)).

As stated in Proposition 2.1, a real trace language L is rational if and only if it can be written as a finite union of sets of the form M · N^{ω} where M, N ⊆ IM(X, D) are rational. For recognizable languages this can be strengthened to the following normal form result.

Proposition 2.11 ([GPZ91]) A real trace language L ⊆ IR(X, D) is recognizable if and only if it can be written as a finite union of sets of the form M ·N_{1}^{ω} ⋯ N_{k}^{ω} = M ·(N_{1} ⋯ N_{k})^{ω} where M, N_{1}, …, N_{k} ⊆ IM(X, D) are recognizable languages such that all traces in N_{i} are connected and have the same alphabet A_{i} with A_{i} × A_{j} ⊆ I for i ≠ j.

Proof: First, it is clear by Remark 2.2, Corollary 2.8 and Proposition 2.10 that every such finite union is recognizable.

The original proof [GPZ91] for the other direction uses Mezei’s Theorem. Here we simply use Ramsey factorization.

Let η′ : IM(X, D) → S′ be a morphism recognizing L ⊆ IR(X, D). We define the direct product S = S′ × P(X) where the operation on the power set P(X) is union and the morphism η : IM(X, D) → S by η(x) = (η′(x), alph(x)) for all x ∈ IM(X, D). Note that η recognizes L, too. Moreover, for s ∈ S, the second projection alph(s) is well-defined and satisfies alph(x) = alph(η(x)) for all x ∈ IM(X, D). This property will be used in the remainder of the proof.

Using Ramsey factorization, recall that we obtain [Gas91]:

L = ⋃_{(s,e)∈P} η^{−1}(s) · η^{−1}(e)^{ω}

where P = {(s, e) ∈ S × S | se = s, e^{2} = e and η^{−1}(s) · η^{−1}(e)^{ω} ∩ L ≠ ∅}. For each (s, e) ∈ P, we decompose the alphabet A = alph(e) into connected components, A = ⋃_{i=1}^{k} A_{i} such that A_{i} is not empty and connected and A_{i} × A_{j} ⊆ I for all i ≠ j. Moreover, we define the finite set

E = {(e_{1}, …, e_{k}) | e = e_{1} ⋯ e_{k} and alph(e_{i}) = A_{i}, for all 1 ≤ i ≤ k}

We claim that

η^{−1}(s)η^{−1}(e)^{ω} = ⋃_{(e_{1},...,e_{k})∈E} η^{−1}(s)η^{−1}(e_{1})^{ω} ⋯ η^{−1}(e_{k})^{ω}

which conclude the proof. Note that, in the definition of E, we could require in addition that se_{i} = s and e_{i}^{2} = e_{i} but this is not necessary for the proof of this proposition.

From the alphabetic property of η, we obtain

η^{−1}(e_{1})^{ω} ⋯ η^{−1}(e_{k})^{ω} = (η^{−1}(e_{1}) ⋯ η^{−1}(e_{k}))^{ω}

Moreover, η^{−1}(e_{1}) ⋯ η^{−1}(e_{k}) ⊆ η^{−1}(e), hence one inclusion is clear.

Conversely, we define a morphism ψ : η^{−1}(e) → E as follows. Let x be in η^{−1}(e). Since alph(x) = alph(e) = A, x admits a unique decomposition in connected components x = x_{1} ⋯ x_{k} such that alph(x_{i}) = A_{i} for all 1 ≤ i ≤ k. Then we set ψ(x) = (η(x_{1}), …, η(x_{k})).

Now, let x_{0}x_{1}x_{2} … ∈ η^{−1}(s)η^{−1}(e)^{ω} with x_{0} ∈ η^{−1}(s) and x_{i} ∈ η^{−1}(e) for all i ≥ 1. Using Ramsey factorization, we obtain an infinite sequence of integers 0 < i_{1} < i_{2} < i_{3} < … and a tuple (e_{1}, …, e_{k}) ∈ E such that ψ(x_{1+i_{j}} … x_{i_{k}}) = (e_{1}, …, e_{k}) for all 1 ≤ j < k. Hence, x_{1+i_{j}} ⋯ x_{i_{j+1}} ∈ η^{−1}(e_{1}) ⋯ η^{−1}(e_{k}) for all j ≥ 1 and we obtain x_{1+i_{1}}x_{2+i_{1}}x_{3+i_{1}} … ∈ (η^{−1}(e_{1}) ⋯ η^{−1}(e_{k}))^{ω} = η^{−1}(e_{1})^{ω} ⋯ η^{−1}(e_{k})^{ω}. This proves the claim since η(x_{0}x_{1} … x_{i_{1}}) = se ⋯ e = se = s. □

Corollary 2.12 The family of recognizable real languages is the smallest family which contains finite sets of finite traces and which is closed under union, concatenation restricted to finitary languages on the left, and Kleene ∗ and ω-iteration both restricted to finitary connected languages.

The final results of this section show the closure of rational and recognizable languages by left and right quotient. These results will become crucial in the next section.

Theorem 2.13 Let K ⊆ IR(X, D) be arbitrary and L ⊆ IR(X, D) be recognizable. Then the following left and right quotients are recognizable, too:

K^{−1} · L = {y ∈ IR(X, D) |
xy ∈ L for some x ∈ K with alphinf(x) × alph(y) ⊆ I}
L · K^{−1} = {x ∈ IR(X, D) |
xy ∈ L for some y ∈ K with alphinf(x) × alph(y) ⊆ I}

If, in addition, K ⊆ IR(X, D) is recognizable, then the quotients are effectively computable.

Proof: Let η : IM(X, D) ⟶ S be a morphism onto a finite monoid S which recognizes L and let X_{s} = η^{−1}(s) for s ∈ S. As in the proof of Proposition 2.11, we may also assume that alph(s) is well-defined for s ∈ S and alph(x) = alph(s) for all x ∈ X_{s}. For s, t ∈ S, we write (s, t) ∈ I if alph(s) × alph(t) ⊆ I. Since recognizable languages are closed under union, we may assume that L = X_{r}X_{d}^{ω} for some r, d ∈ S with rd = r and d^{2} = d. Using Theorem 2.7 and Proposition 2.10, the result follows from the claim:

K^{−1} · L = ⋃_{(t,f)∈Q} X_{t}X_{f}^{ω}

where

Q = {(t, f) ∈ S × S | tf = t, f^{2} = f and X_{s}X_{e}^{ω} ∩ K ≠ ∅
for some (s, e) ∈ S × S
with se = s, e^{2} = e, r = st, d = ef,
and (e, tf) ∈ I}.

Note that the computation of Q is effective as soon as K is recognizable.

Let y ∈ X_{t}X_{f}^{ω} for (t, f) ∈ Q. Choose x ∈ X_{s}X_{e}^{ω} ∩ K accordingly to the definition of Q. Then we have

xy ∈ X_{s}X_{e}^{ω}X_{t}X_{f}^{ω} = X_{s}X_{t}(X_{e}X_{f})^{ω} ⊆ X_{r}X_{d}^{ω} = L

Hence, one inclusion of the claim is trivial.

For the other direction, let y ∈ K^{−1} · L and choose x ∈ K such that xy ∈ L with alphinf(x) × alph(y) ⊆ I. Then we can write xy = z_{1}z_{2} … with z_{1} ∈ X_{r} and z_{i} ∈ X_{d} for i ≥ 2. Hence, there exist x_{1}, x_{2}, …, y_{1}, y_{2}, … such that z_{i} = x_{i}y_{i} for i ≥ 1, x = x_{1}x_{2} …, y = y_{1}y_{2} …, and (y_{i}, x_{j}) ∈ I for i < j. Ramsey factorization applied to the sequence x = x_{1}x_{2} … shows that we may assume x_{1} ∈ X_{s}, x_{i} ∈ X_{e} for i ≥ 2 and some s, e ∈ S such that se = s and e^{2} = e. In the next step, applying the same argument to the sequence y = y_{1}y_{2} …, we may assume y_{1} ∈ X_{t}, y_{i} ∈ X_{f} for i ≥ 2 and some t, f ∈ S with tf = t and f^{2} = f. Since alphinf(x) = alph(e) and alph(y) = alph(tf), we have (e, tf) ∈ I. Hence (t, f) ∈ Q. This shows the other inclusion. The proof for L · K^{−1} is symmetric. □

For rational languages such a general result does not hold. We have the following counter example.

Example: Let IM(X, D) = {a, b}^{∗}×{c, d}^{∗}×{e}^{∗} be a direct product of three free monoids. Consider the following two rational sets: K = (ae)^{∗}b and L = (ac)^{∗}b(de)^{∗}. Then we have K^{−1}L ⊆ {c, d}^{∗} × {e}^{∗}. The projection of K^{−1}L to {c, d}^{∗} yields the non-rational set {w ∈ {c, d}^{∗} | |w|_{c} ≤ |w|_{d}}. In order to have an example of ω- languages, simply substitute b by b^{ω}.

However, the quotient of a rational language by a recognizable language is effectively rational. This is stated in the next Theorem.

Theorem 2.14 Let K ⊆ IR(X, D) be recognizable and L ⊆ IR(X, D) be rational. Then the following left and right quotients are effectively computable and rational, too:

K^{−1} · L = {y ∈ IR(X, D) |

xy ∈ L for some x ∈ K with alphinf(x) × alph(y) ⊆ I}

L · K^{−1} = {x ∈ IR(X, D) |

xy ∈ L for some y ∈ K with alphinf(x) × alph(y) ⊆ I}

Proof: We give the proof for K^{−1} · L only. The other case L · K^{−1} is obtained analogously. Let K′ = φ^{−1}(K) and L′ ⊆ X^{∞} be a regular language such that φ(L′) = L. Let X_{1}, X_{2} be two copies of X and let X̂ = X_{1} ∪ X_{2}. Define three morphisms h, p_{1}, p_{2} from X̂^{∞} in X^{∞} by h(a_{i}) = a, p_{i}(a_{i}) = a and p_{j}(a_{i}) = 1 for i, j = 1, 2 with i ≠ j. Finally, define the regular language W ⊆ X̂^{∞} by its complement \overline{W} = ∪_{(a,b)∈D}X̂^{∗}b_{2}X̂^{∗}a_{1}X̂^{∞}.

Since regular word languages are closed under morphism, inverse morphism and intersection, the language N′ = p_{2}(p_{1}^{−1}(K′)∩h^{−1}(L′)∩W) is regular, too. Moreover, it is easy to verify that

N′ = {v_{1}v_{2} … ∈ X^{∞} | ∃u_{1}u_{2} … ∈ K′ with u_{1}v_{1}u_{2}v_{2} … ∈ L′ and (v_{i}, u_{j}) ∈ I for all i < j}
= {v ∈ X^{∞} | (u ⊔⊔_{I} v) ∩ L′ ≠ ∅ for some u ∈ K′}

We claim that φ(N′) = K^{−1} ·L which proves that K^{−1} ·L is rational.

Let v be in N′. There exists w ∈ (u ⊔⊔_{I} v) ∩ L′ for some u ∈ K′. In the proof of Proposition 2.10 we have shown that φ(w) = φ(u) · φ(v). Therefore, φ(v) ∈ K^{−1} · L.

Conversely, let y be in K^{−1} · L. There exists x ∈ K such that alphinf(x) × alph(y) ⊆ I and z = xy ∈ L. Let w ∈ φ^{−1}(z) ∩ L′. In the proof of Proposition 2.10 we have shown that φ^{−1}(xy) = φ^{−1}(x)⊔⊔_{I} φ^{−1}(y). Hence, there exist u ∈ φ^{−1}(x) and v ∈ φ^{−1}(y) such that w ∈ u ⊔⊔_{I} v, whence (u ⊔⊔_{I} v) ∩ L′ ≠ ∅. Since u ∈ φ^{−1}(x) ⊆ φ^{−1}(K) = K′, we obtain v ∈ N′. □

3 Rational and recognizable complex trace languages

Recall the following notations. Let L ⊆ C(X, D) be a complex trace language and A ⊆ X be a subset of the alphabet. We denote by L_{A} = {x ∈ L | Im(x) = D(A)} and μ_{A}(L) = {μ_{A}(x) | x ∈ L} where μ_{A}(x) is the maximal real prefix of Re(x) containing letters independent of A, only. It will be useful to have a finer partition. Let L ⊆ C(X, D) and A, B ⊆ X. We define L_{A,B} = {x ∈ L | Im(yx) = D(B) for some y ∈ C(X, D)_{A}}. Note that in the definition above the existential “for some” can be replaced by “for all”. The reason to introduce L_{A,B} is that if we concatenate any complex trace y ∈ C(X, D)_{A} with some x ∈ L such that yx ∈ C(X, D)_{B}, then in fact x ∈ L_{A,B}. Note that in this case Re(yx) = Re(y)μ_{A}(x), therefore, we are also interested in the language μ_{A,B}(L) which is defined by μ_{A,B}(L) = μ_{A}(L_{A,B}).

The formulae given in the next lemma will be useful throughout.

Lemma 3.1 Let K, L ⊆ C(X, D) be complex trace languages and B ⊆ X. Then the following formulae hold:

i) L_{B} = L_{∅,B}

ii) L = ⋃_{C⊆X} L_{B,C}

iii) μ_{B}(L) = ⋃_{C⊆X} μ_{B,C}(L)

iv) (KL)_{B} = ⋃_{A⊆X} K_{A}L_{A,B}

v) Re((KL)_{B}) = ⋃_{A⊆X} Re(K_{A})μ_{A,B}(L)

Proof: i) is obvious. ii) Let x ∈ L and y ∈ C(X, D)_{B}. Then, D(B) ⊆ Im(yx) = D(C) for some C ⊆ X. Therefore x ∈ L_{B,C}. iii) follows since μ_{A} commutes with union. iv) We have (KL)_{B} = ⋃_{A⊆X}(K_{A}L)_{B} = ⋃_{A⊆X}(K_{A}L_{A,B}). At last, for any x ∈ K_{A} and any y ∈ L_{A,B}, Re(xy) = Re(x)μ_{A}(y) and v) follows from iv). □

Finally, we define ν_{A}(L) = μ_{A,A}(L). Each trace in ν_{A}(L) is finite since alph(u) ⊆ I(A) and Im(u) ⊆ D(A) implies Im(u) = ∅. Note also that ν_{∅}(L) is just the finitary part L_{∅} = L ∩ IM(X, D). Later, we will introduce finite components, which could be characterized as the union of ν_{A}(L) over A ⊆ X. For the moment we are interested in the ν_{A}(L), because we have the following formula.

Lemma 3.2 Let L ⊆ C(X, D) be a complex trace language and † ∈ {∗, ω}. Let A be the finite set of sequences A = {(A_{0}, …, A_{k}) | ∅ = D(A_{0}){⊂ \atop ≠} ⋯ {⊂ \atop ≠}D(A_{k}) ⊆ X\}. Then the language L^{†} is the finite union

L^{†} = ⋃_{(A_{0},...,A_{k})∈A} ν_{A_{0}}(L)^{∗}L_{A_{0},A_{1}} … ν_{A_{k−1}}(L)^{∗}L_{A_{k−1},A_{k}}ν_{A_{k}}(L)^{†} Proof: The proof uses in a crucial way the observation that, if x, y ∈ C(X, D) and Im(x) = Im(xy) = D(A) then μ_{A}(y) = ν_{A}(y) and xy = xν_{A}(y).

Let x = x_{1}x_{2} … ∈ L^{†}, x_{i} ∈ L. Eventually, the sequence of alphabets Im(x_{1}) ⊆ Im(x_{1}x_{2}) ⊆ ⋯ becomes stationary. Therefore, there exist an integer k, a sequence of integers 0 = i_{0} < i_{1} < … < i_{k} < i_{k+1} = ω and a sequence (A_{0}, …, A_{k}) ∈ A such that Im(x_{1} … x_{n}) = D(A_{j}) for all i_{j} ≤ n < i_{j+1} and 0 ≤ j ≤ k. Define now the sequence (y_{n})_{n≥1} by y_{n} = ν_{A_{j}}(x_{n}) ∈ ν_{A_{j}}(L) if i_{j} < n < i_{j+1} for some 0 ≤ j ≤ k and by y_{n} = x_{n} ∈ L_{A_{j−1},A_{j}} if n = i_{j} for some 1 ≤ j ≤ k. From the observation above, it follows x_{1} … x_{n} = y_{1} … y_{n} for all n and thus x = y_{1}y_{2} … y_{n} . . .. Therefore,

x ∈ ν_{A_{0}}(L)^{∗}L_{A_{0},A_{1}} … ν_{A_{k−1}}(L)^{∗}L_{A_{k−1},A_{k}}ν_{A_{k}}(L)^{†}

Conversely, we show by induction on k that ν_{A_{0}}(L)^{∗}L_{A_{0},A_{1}} … ν_{A_{k−1}}(L)^{∗} L_{A_{k−1},A_{k}}ν_{A_{k}}(L)^{†} ⊆ L^{†}, for any (A_{0}, …, A_{k}) ∈ A. For k = 0 this formula becomes ν_{∅}(L)^{†} = L_{∅}^{†} ⊆ L^{†} which is clear. Assume that, for any (A_{0}, …, A_{k}) ∈ A, the inclusion holds and let (A_{0}, …, A_{k+1}) ∈ A. By induction hypothesis applied to (A_{0}, …, A_{k}), we have in particular:

ν_{A_{0}}(L)^{∗}L_{A_{0},A_{1}} … ν_{A_{k−1}}(L)^{∗}L_{A_{k−1},A_{k}}ν_{A_{k}}(L)^{∗} ⊆ L^{∗}  (5)

Since all the complex traces belonging to the left hand side of Equation (5) have clearly D(A_{k}) as imaginary part, it follows:

ν_{A_{0}}(L)^{∗}L_{A_{0},A_{1}} … ν_{A_{k−1}}(L)^{∗}L_{A_{k−1},A_{k}}ν_{A_{k}}(L)^{∗} ⊆ (L^{∗})_{A_{k}}

Therefore the inclusion for (A_{0}, …, A_{k+1}) follows since (L^{∗})_{A_{k}}L_{A_{k},A_{k+1}} ⊆ (L^{∗})_{A_{k+1}} and, from the observation above, (L^{∗})_{A_{k+1}}ν_{A_{k+1}}(L)^{†} ⊆ L^{†} for † ∈ {∗, ω}. □

We are now ready to define rational and recognizable complex trace languages. There will be various equivalent characterizations for these notions which justify the following definition.

Definition: A complex trace language L ⊆ C(X, D) is called rational (recognizable respectively) if for all A ⊆ X the real language Re(L_{A}) is rational (recognizable respectively). The families are denoted by Rat(C(X, D)) and Rec(C(X, D)) respectively.

Proposition 3.3 The family Rec(C(X, D)) is a boolean algebra : it is closed under union, intersection, and complementation. The family Rat(C(X, D)) is closed under union.

Proof: Since Re : C(X, D) → IR(X, D) commutes with union, it follows from results of Section 2 on real traces that Rat(C(X, D)) and Rec(C(X, D)) are closed under union. The closure of Rec(C(X, D)) under intersection and complementation follows from Remark 2.2 and the formulae: for all K, L ⊆ C(X, D) and A ⊆ X, Re(K_{A} ∩ L_{A}) = Re(K_{A}) ∩ Re(L_{A}) and Re((C(X, D) \ K)_{A}) = Re(C(X, D)_{A}) \ Re(K_{A}). □

For any real trace language L ⊆ IR(X, D) and any subset A ⊆ X, it holds Re(L_{A}) = {r ∈ L | Im(r)} = D(A)} = L ∩ IR(X, D)_{A}. Since

φ^{−1}(IR(X, D)_{A}) = ⋃_{{B⊆X|D(B)=D(A)}}{x ∈ X^{∞} | alphinf(x) = B}

the set IR(X, D)_{A} is a recognizable real trace language. Therefore if L is a rational (recognizable respectively) real trace language, then so is Re(L_{A}) for any A ⊆ X. Hence L is also a rational (recognizable respectively) complex trace language. More precisely, we have (as expected) Rat(IR(X, D)) = {L ⊆ IR(X, D) | L ∈ Rat(C(X, D))} and Rec(IR(X, D)) = {L ⊆ IR(X, D) | L ∈ Rec(C(X, D))}. At last, note that since Re(L) = ⋃_{A⊆X} Re(L_{A}), we have also the inclusionsRe(Rat(C(X, D))) ⊆ Rat(IR(X, D)) and Re(Rec(C(X, D))) ⊆ Rec(IR(X, D)). The situation is summarized in the following figure.

Rec(IR(X, D)) ⊆ Rec(C(X, D)) ⟶^{Re} Rec(IR(X, D))
∩ ∩ ∩
Rat(IR(X, D)) ⊆ Rat(C(X, D)) ⟶^{Re} Rat(IR(X, D))

Before we continue the reader should be convinced that it makes no sense to define a language L ⊆ C(X, D) to be rational (recognizable respectively) if the projection Re(L) ⊆ IR(X, D) is rational (recognizable respectively). Both classes of languages would be uncountable. (Note that the families of rational and recognizable complex trace languages are countable. Indeed, a complex trace language is entirely defined by the languages L_{A} for A ⊆ X and the family of rational real trace languages is countable since it is defined by rational expressions.) For instance, if (X, D) = a b c, for any P ⊆ IN, the language L_{P} = {(φ(b)^{j}φ(a)^{ω}, D(a)) | j ∈ P } ∪ {(φ(b)^{j}φ(a)^{ω}, D(a, b)) | j ∉ P } verifies φ^{−1}(Re(L_{P})) = a^{∗}b^{ω} and would be therefore recognizable. Note also that the family of recognizable languages would not be closed under intersection. Namely if (X, D) = a b c d and L = φ(ac)^{∗}φ(b)^{ω}φ(c) ∪ {φ(a), φ(c)}^{∗}φ(b)^{ω}, Re(L) = {φ(a), φ(c)}^{∗}φ(b)^{ω} is a recognizable real trace language whereas L_{{b,c}} = L∩C(X, D)_{{b,c}} is not recognizable since Re(L_{{b,c}}) = φ(ac)^{∗}φ(b)^{ω}. Similarly, since the canonical mapping φ : X^{∞} → C(X, D) is not surjective, it cannot be used neither to define a language L ⊆ C(X, D) to be recognizable. For example, simply asking that φ^{−1}(L) ⊆ X^{∞} has to be regular would yield that any language not containing real traces is recognizable. (Of course, according to our definition, L ∈ Rec(C(X, D)) implies that φ^{−1}(L) ⊆ X^{∞} is regular.)

Lemma 3.4 Let L ⊆ C(X, D) be rational (recognizable respectively) and A, B ⊆ X. Then the languages L_{A,B} ⊆ C(X, D) and μ_{A,B}(L) ⊆ IR(X, D) are rational (recognizable respectively).

Proof: First, we show the assertion for L_{A,B}. Note that (L_{A,B})_{C} = (L_{C})_{A,B} for all C ⊆ X. Thus,

Re((L_{A,B})_{C}) = Re((L_{C})_{A,B})

= Re({x ∈ L_{C} | Im(yx) = D(B) for some y ∈ C(X, D)_{A}})

= {r ∈ Re(L_{C}) | Im(yr) ∪ D(C) = D(B)
for some y ∈ C(X, D)_{A}}
= Re(L_{C}) ∩ K

where K = {r ∈ IR(X, D) | D(A ∪ C ∪ Suff_{A}(r)) = D(B)}.

Using Remark 2.2 and Lemma 2.4, we are reduced to prove that the language K is recognizable. Indeed, it is easy to verify that the language φ^{−1}(K) is accepted by the following deterministic Büchi automaton. The set of states is P(X), the initial state is A and for all q ∈ P(X) and a ∈ X we have the transition (q, a, q′) where q′ = q ∪ {a} if a ∈ D(q) and q′ = q otherwise. A transition (q, a, q′) is final if and only if D(A ∪ C ∪ q) = D(B).

For μ_{A,B}(L) we have μ_{A,B}(L) = μ_{A}(L_{A,B}) by definition. Hence it is enough to show the assertion for μ_{A}(L). Since μ_{A}(L) = μ_{A}(Re(L)), we are reduced to consider real trace language L ⊆ IR(X, D).

For L ⊆ IR(X, D) we have μ_{A}(L) = M ∩(L·Suff_{A}^{−1}) where M = {x ∈ IR(X, D) | alph(x) ⊆ I(A)} and

Suff_{A} = {r ∈ IR(X, D) | min(r) ⊆ D(A)} = IR(X, D)\⋃_{a∈I(A)} a·IR(X, D)

Since M and Suff_{A} are recognizable, the results follow from Lemma 2.4, Theorems 2.13, and 2.14. □

So far, we have allowed as rational operation on real traces the concatenation K · L, only if K is finitary. This was motivated by the fact that IR(X, D) is not a monoid. For complex traces such a restriction is obviously not adequate and our first result underlines this. It follows directly from Lemma 3.1, v), Proposition 2.10 and Lemma 3.4.

Theorem 3.5 Let K, L ∈ C(X, D) be rational (recognizable respectively). Then the concatenation K · L has the same property.

We can now extend Proposition 2.1 and Proposition 2.11 and give normal forms for rational and recognizable complex trace languages.

Corollary 3.6 i) A language L ⊆ C(X, D) is rational if and only if it can be written as a finite union of sets of the form MN^{ω}s where M, N ⊆ IM(X, D) are finitary and rational and s ∈ IM(X, D) is a finite (shift-)trace.

ii) A language L ⊆ C(X, D) is recognizable if and only if it can be written as a finite union of sets of the form MN_{1}^{ω} … N_{k}^{ω}s where M, N_{1}, …, N_{k} ⊆ IM(X, D) are finitary and recognizable, each trace in N_{i} has the same connected alphabet A_{i}, A_{i} × A_{j} ⊆ I for i ≠ j, and s ∈ IM(X, D) is a finite (shift-)trace.

Proof: We have seen in the preliminaries every complex trace language L ⊆ C(X, D) can be written as a finite union:

L = ⋃_{A shift B}(Re(L_{B}) ∩ IR(X, D)_{A})s_{A,B}

where s_{A,B} is some finite shift trace from D(A) to D(B). Hence if L is rational (recognizable respectively), Proposition 2.1 (Proposition 2.11 respectively) applied to languages Re(L_{B}) ∩ IR(X, D)_{A} yield the only-if parts of the corollary. The if-parts come from the inclusions Rat(IR(X, D)) ⊆ Rat(C(X, D)) (Rec(IR(X, D)) ⊆ Rec(C(X, D)) respectively) and the closures under concatenation, Theorem 3.5. □

Since the concatenation and the ω-product are fully defined in C(X, D), the ∗-iteration and the ω-iteration should be allowed as rational operations, in full generality. The next theorem states that this is indeed the case.

Theorem 3.7 Let L ∈ Rat(C(X, D)) be a rational complex trace language. Then L^{∗} and L^{ω} are rational.

Proof: If L is a rational complex trace language, from Lemma 3.4, we deduce in particular that ν_{A}(L) ⊆ IM(X, D) is a finitary rational trace language for all A ⊆ X. Hence, for all A ⊆ X, ν_{A}(L)^{∗} and ν_{A}(L)^{ω} are rational real trace languages, too. Thus, the theorem follows from Lemma 3.2, Proposition 3.3 and Theorem 3.5. □

From closure under union, Theorems 3.5, 3.7 and Corollary 3.6, we obtain the following characterization which could also be used for a convenient definition of rational complex trace languages.

Corollary 3.8 The family of rational complex trace languages is the smallest family which contains all finitary rational trace languages and which is closed under union, concatenation, Kleene-∗, and ω-iteration.

Of course, we cannot expect that recognizable languages are closed under Kleene-∗ or ω-iteration, in general. However, let L be a recognizable complex trace language such that ν_{A}(L)^{∗} ⊆ IM(X, D) is recognizable for all A ⊆ X. From Theorem 2.7, we deduce that, for all A ⊆ X, ν_{A}(L)^{ω} is recognizable, too. Hence, from Lemma 3.2 and closures under union and concatenation we obtain the following corollary. It is our strongest result concerning the question when the star- and ω-iteration of a recognizable complex trace language is recognizable.

Corollary 3.9 Let L ⊆ C(X, D) be a recognizable complex trace language such that ν_{A}(L)^{∗} ⊆ IM(X, D) is recognizable for all A ⊆ X. Then L^{∗} and L^{ω} are recognizable complex trace languages, too. □

We finish this section by an extension of Theorems 2.13 and 2.14 to complex trace languages.

Theorem 3.10 Let K ⊆ C(X, D) be arbitrary (recognizable respectively) and L ⊆ C(X, D) be recognizable (rational respectively). Then the following left and right quotients are recognizable (rational respectively), too:

L · K^{−1} = {x ∈ C(X, D) | xy ∈ L for some y ∈ K}
K^{−1} · L = {y ∈ C(X, D) | xy ∈ L for some x ∈ K}

If K is recognizable, then the quotients are effectively computable.

Proof: First we consider Re((L · K^{−1})_{A}) for some A ⊆ X. We have

(L · K^{−1})_{A} = ⋃_{B⊆X}(L_{B} · K^{−1})_{A} = ⋃_{B⊆X}(L_{B} · K_{A,B}^{−1})_{A}

Hence, it remains to prove that Re((L_{B} · K_{A,B}^{−1})_{A}) is a recognizable (rational respectively) real trace language. We have

Re((L_{B} · K_{A,B}^{−1})_{A}) = {r ∈ Re(C(X, D)_{A}) | r · μ_{A}(y) ∈ Re(L_{B})
for some y ∈ K_{A,B}}
= Re(C(X, D)_{A}) ∩ Re(L_{B}) · (μ_{A,B}(K))^{−1}

Hence, the results follow from Remark 2.2, Lemma 2.4, Theorems 2.13, 2.14 and Lemma 3.4.

The calculus for K^{−1}·L is slightly different. First, note that K^{−1}·L = ∪_{A⊆B⊆X}K_{A}^{−1} · L_{B}. Then we have

K_{A}^{−1} · L_{B} = {y ∈ C(X, D)_{A,B} | rμ_{A}(y) ∈ Re(L_{B}) for some r ∈ Re(K_{A})}

= C(X, D)_{A,B} ∩ {y ∈ C(X, D) | μ_{A}(y) ∈ Re(K_{A})^{−1} · Re(L_{B})}

Since by Theorems 2.13 and 2.14, Re(K_{A})^{−1} · Re(L_{B}) is recognizable (rational respectively) the results follow from the claim:

Claim: Let R ⊆ IR(X, D) be rational (recognizable respectively) then M = {y ∈ C(X, D) | μ_{A}(y) ∈ R} is rational (recognizable respectively).

For all B ⊆ X, we have Re(M_{B}) = Re(C(X, D)_{B}) ∩ {r ∈ IR(X, D) | μ_{A}(r) ∈ R}. Therefore, the claim follow directly from

{r ∈ IR(X, D) | μ_{A}(r) ∈ R} = ({r ∈ IR(X, D) | alph(r) ⊆ I(A)}∩R)·Suff_{A}

where Suff_{A} is the recognizable set defined in Lemma 3.4. □

In the section below we will introduce connected and finitary connected components and we will extend Kleene’s and Ochmanski’s theorems to complex trace languages.

4 C-rational complex trace languages

In order to define concurrent iterations for complex trace languages, we need first a notion of connectedness for complex traces. Intuitively, a trace is connected if it cannot be split into two non-empty independent traces. Thus, let us introduce the notion of independence. This notion is clear in G(X, D): two graphs f and g are independent if alph(f) × alph(g) ⊆ I. Unfortunately, we cannot use this definition in C(X, D) since the alphabet of a complex trace is not well-defined. Nevertheless, it is easy to verify that the independence relation in G(X, D) factorizes to complex traces. Hence the independence relation in C(X, D) is welldefined and can be characterized as follows. Two complex traces x = (u, D(A)), y = (v, D(B)) ∈ C(X, D) are independent if (alph(u) ∪ A) × (alph(v) ∪ B) ⊆ I, in this case we will simply write (x, y) ∈ I. Note that this is well-defined since D(B) = D(B′) implies (alph(u) ∪ A) × (alph(v) ∪ B) ⊆ I ⇔ (alph(u) ∪ A) ∩ D(alph(v) ∪ B) = ∅ ⇔ (alph(u) ∪ A) ∩ D(alph(v) ∪ B′) = ∅ ⇔ D(alph(u) ∪ A) ∩ (alph(v) ∪ B′) = ∅ This leads to the following definition.

Definition: A complex trace z is called connected if for all factorization z = xy where x, y are independent, either x = 1 or y = 1. A trace x is called a connected component of z ∈ C(X, D) if either x = z = 1 or x is a non-empty connected trace such that z = xy for some y independent of x. The trace z is said to be finitary connected if it admits at most one finite connected component.

For any non-empty trace z, we will denote by C(z) (respectively FC(z) = C(z) ∩ IM(X, D)) the set of connected components (respectively finite connected components) of z. These notations are as usual extended to languages. A language is said to be connected (respectively finitary connected) if all its elements are connected (respectively finitary connected).

Note that a direct translation of the above definition can be used to define connectedness notions on dependence graphs as well. These notions coincide with the natural notion of connectedness in G(X, D): a dependence graph is connected if and only if so is its underlying undirected graph. Unfortunately, this natural notion does not factorize to complex traces. The same complex trace might have connected as well as disconnected representing dependence graphs. For example let (X, D) = a b c. Then the complex trace x = ((ac)^{ω}, X) is represented by the connected dependence graph (ac)^{ω}b as well as by the disconnected graph a^{ω}c^{ω}. This explains why we define the notion of connected traces through the independence relation. For finitary connectedness the situation is simpler. A trace x ∈ IM(X, D) is a finite connected component of z ∈ C(X, D) if and only if x is finite and a connected component of any representing dependence graph of z. The following proposition precises the links between the two notions of connectedness in G(X, D) and C(X, D).

Proposition 4.1 Let x ∈ C(X, D) be a complex trace.

i) x is connected if and only if all its representatives in G(X, D) are connected.

ii) Let f ∈ G(X, D) be any representative of x and let {f_{1}, …, f_{k}} be the set of finite connected components of f. Then FC(x) = {f_{1}, …, f_{k}}.

Proof: i) Let f be a representative of x in G(X, D). Suppose that f = gh with alph(g) × alph(h) ⊆ I. Let y, z be the complex traces represented by g, h respectively. Hence x = yz with (y, z) ∈ I. Since x is connected, we get y = 1 or z = 1 and thus g = 1 or h = 1. Therefore f is connected. Conversely, suppose that x = yz with (y, z) ∈ I. Let g, h be representatives in G(X, D) of the complex traces y, z respectively. Hence gh is a representative of x and (g, h) ∈ I. Thus g = 1 or h = 1, hence y = 1 or z = 1 and x is connected. ii) Let g be a finite connected component of f, f = gh for some h ∈ G(X, D) with alph(g) × alph(h) ⊆ I. Let y be the complex trace represented by h. Since g is finite, we get x = gy with (g, y) ∈ I. Moreover g is a connected complex trace from i). Hence g ∈ FC(x). Conversely, let y ∈ FC(x). Then x = yz for some complex trace z such that (y, z) ∈ I. Since G(X, D) is left cancellative [Die91], the dependence graph y^{−1}f is well-defined and is a representative of the complex trace z. Hence y is a finite connected component of f = y(y^{−1}f). □

In order to generalize Büchi’s and Ochmanski’s Theorems to complex traces, we need a link to the language ν_{A}(L) defined above. For a complex trace x, any non-empty product over pairwise independent finite connected components of x is called a finite component of x. For a language L ⊆ C(X, D), the set of finite components of the elements of L is denoted by FinComp(L).

Lemma 4.2 Let L ⊆ C(X, D) be recognizable. Then the following assertions hold. i) FinComp(L) = ⋃_{A⊆X} ν_{A}(L)

ii) FC(L) and C(L) are recognizable

Proof: i) Let t ∈ ν_{A}(L). By definition, we have alph(t) ⊆ I(A) and Im(t) ⊆ D(A), hence Im(t) = ∅ and thus t is finite. Moreover, there exists some x ∈ L_{A,A} such that t = μ_{A}(x). Hence x = t · (r, Im(x)) and, since x ∈ L_{A,A}, we have (D(alph(r)) ∪ Im(x)) ⊆ D(A). Thus, from alph(t) ⊆ I(A), (t, (r, Im(x))) ∈ I. Therefore t ∈ FinComp(L_{A,A}) ⊆ FinComp(L).

Conversely, let t ∈ FinComp(L), there exist some u ∈ L and v ∈ C(X, D) such that u = tv with (t, v) ∈ I. Let B = alph(t) and A = I(B), note that B ⊆ I(A). We claim that t = μ_{A}(u) and u ∈ L_{A,A} whence t ∈ ν_{A}(L). Let v = (r, D(C)), since (t, v) ∈ I, we have by definition B × (alph(r) ∪ C) ⊆ I, and thus (alph(r) ∪ C) ⊆ I(B) = A. Hence alph(r) ⊆ A, in particular alph(r) ∩ I(A) = ∅ and then μ_{A}(u) = t. We get also C ⊆ A, hence u ∈ L_{A,A} and the claim is proved.

ii) Let NC be the set of non-connected complex traces. It is easy to verify that NC = ⋃_{(A∪B)×(E∪F)⊆I} K(A, B) · K(E, F) where, for all A, B ⊆ X, K(A, B) = {x ∈ C(X, D)_{B} \ {1} | alph(Re(x)) = A}. Now, it turns out that

C(L) = (⋃_{(A∪B)×(E∪F)⊆I}(K(A, B)^{−1} · L) ∩ K(E, F)) ∩ (C(X, D) \ NC)

Clearly, for all A, B ⊆ X, the set K(A, B) is recognizable. From Proposition 3.3 and Theorems 3.5 and 3.10, we deduce that NC and C(L) are recognizable. Thus the set FC(L) = C(L) ∩ IM(X, D) is recognizable, too.□

Theorem 4.3 Let L ⊆ C(X, D) be recognizable. If L is finitary-connected (in particular if L is connected) or if FC(L) ⊆ L^{∗}, then L^{∗} and L^{ω} are recognizable.

Proof: If L is finitary connected, then FinComp(L) is connected and from Lemma 4.2 i), it holds that ν_{A}(L) is connected for all A ⊆ X.

Since by Lemma 3.4 ν_{A}(L) is also recognizable, ν_{A}(L)^{∗} is recognizable by [Mét86, Och85]. Hence L^{∗} and L^{ω} are recognizable by Corollary 3.9.

Assume that FC(L) ⊆ L^{∗}. We will also show that ν_{A}(L)^{∗} is recognizable for all A ⊆ X. For this purpose, we claim that ν_{A}(L)^{∗} = ν_{A}(FC(L))^{∗}.

Remark first that if t is a finite connected trace, from Lemma 4.2 i) applied to L = {t}, we get that, for any A ⊆ X, either ν_{A}(t) = {t} if alph(t) ⊆ I(A) or ν_{A}(t) = ∅ otherwise.

Let now t be in ν_{A}(L) and {t_{1}, …, t_{k}} be the connected components of t. From Lemma 4.2 i), we have {t_{1}, …, t_{k}} ⊆ C(FinComp(L)) = FC(L). From the remark above, for all 1 ≤ i ≤ k, we get {t_{i}} = ν_{A}(t_{i}) and thus t_{i} ∈ ν_{A}(FC(L)). Hence ν_{A}(L) ⊆ ν_{A}(FC(L))^{∗}, and ν_{A}(L)^{∗} ⊆ ν_{A}(FC(L))^{∗}, too.

Conversely, since FC(L) ⊆ L^{∗}, we have ν_{A}(FC(L)) ⊆ FinComp(FC(L)) = FC(L) ⊆ L^{∗}. Let t ∈ ν_{A}(FC(L)) ⊆ L^{∗}, in particular alph(t) ⊆ I(A) and t = t_{1} … t_{k} with t_{i} ∈ L_{∅} and alph(t_{i}) ⊆ I(A) for 1 ≤ i ≤ k. From the remark above, {t_{i}} = ν_{A}(t_{i}) ⊆ ν_{A}(L), for 1 ≤ i ≤ k. Therefore t ∈ ν_{A}(L)^{∗} and ν_{A}(FC(L)) ⊆ ν_{A}(L)^{∗}. Finally ν_{A}(L)^{∗} = ν_{A}(FC(L))^{∗} and the claim is proved.

Since ν_{A}(FC(L)) is connected, we obtain from [Mét86, Och85] that ν_{A}(L)^{∗} is recognizable. □

Corollary 4.4 Let L ⊆ C(X, D) be a recognizable, then (FC(L) ∪ L)^{∗} and (FC(L) ∪ L)^{ω} are recognizable, too.

Proof: This is immediate from the theorem above and the observation that we have FC(FC(L) ∪ L) = FC(L). □

Beside its own interest, Corollary 4.4 yields a simple proof of the following result which is surprising, since the ∗-iteration of a single trace is not recognizable, in general.

Corollary 4.5 Let x ∈ C(X, D) be a recognizable complex trace, i.e., {x} ∈ Rec(C(X, D)), then x^{ω} is recognizable.

Proof: Choose A ⊆ X such that D(A) = Im(x^{ω}). Then we claim that

{x^{ω}} = ((FC({x}) ∪ {x})^{ω})_{A}

One inclusion is obvious. Conversely, let z ∈ ((FC({x})∪{x})^{ω})_{A}. Since Im(z) = Im(x^{ω}) = D(alph(Re(x))) ∪ Im(x), we deduce that z = zx = zx^{ω}. Now, let FC({x}) = {x_{1}, …, x_{k}} and let y = (x_{1} … x_{k})^{−1} · x. From the definition of connected components, it holds that x_{1}, …, x_{k}, y are pairwise independent. Therefore z = x_{1}^{n+n_{1}} … x_{k}^{n+n_{k}}y^{n} for some 0 ≤ n_{1}, …, n_{k}, n ≤ ω, x^{ω} = x_{1}^{ω} … x_{k}^{ω}y^{ω} and hence zx^{ω} = x^{ω}. □

Now, we extend the concurrent iteration of Ochmanski [Och85] to complex traces.

Definition: Let L ⊆ C(X, D). Then the concurrent iterations of L are defined by L^{c−∗} = (C(L))^{∗} and L^{c−ω} = (C(L))^{ω}.

Since C(L) is connected, we obtain from Lemma 4.2 and Theorem 4.3:

Corollary 4.6 Let L ⊆ C(X, D) be recognizable. Then L^{c−∗} and L^{c−ω} are recognizable.

Definition: The family of c-rational complex trace languages,c − Rat( C(X, D)), is the smallest family which contains all finite sets of finite traces and which is closed under the operations union, concatenation and concurrent iterations c-∗ and c-ω.

We are now ready to state our main result.

Theorem 4.7 Rec(C(X, D)) = c − Rat(C(X, D))

Proof: We have seen that Rec(C(X, D)) is a boolean algebra closed under concatenation (Theorem 3.5) and concurrent iterations (Corollary 4.6). Hence c − Rat(C(X, D)) ⊆ Rec(C(X, D)). Conversely, we have seen (Corollary 3.6) that every recognizable language can be written as a finite union over languages of type MN_{1}^{ω} … N_{k}^{ω}s where M, N_{1}, …, N_{k} ⊆ IM(X, D) are recognizable and s ∈ IM(X, D) is a finite trace. Moreover all traces in N_{i} have the same connected alphabet and hence N_{i}^{ω} = N_{i}^{c−ω}. From Ochmanski’s theorem [Och85], the recognizable finitary languages M and N_{i}, for 1 ≤ i ≤ k, are in c − Rat(C(X, D)). Therefore L is also in c − Rat(C(X, D)). □

Remark 4.8 i) Every recognizable complex trace language has effectively a c-rational expression where the concurrent iterations are allowed only for finitary languages which are connected. (Hence where the concurrent iterations become the usual Kleene-∗ and ω-iteration.)

ii) We could have defined the finitary concurrent iteration of a language L as L^{fc−†} = (FC(L) ∪ L)^{†} for † ∈ {∗, ω}. An analogue of Theorem 4.7 with a suitable definition of fc − Rat(C(X, D)) also holds in this case.

5 Conclusion

In this paper we have studied the families of rational and recognizable languages of complex traces. We showed that classical results on finite and infinite words and finite traces have a natural extension to complex traces. In our investigations we followed mainly an algebraic viewpoint with the final goal to establish the Kleene-Ochmanki-Theorem.

Of course, other characterizations of the recognizable languages are of high interest. For instance, word languages can be defined by monadic second order logic [Büc62]. The equivalent work for finite traces can be found in [Tho90] and for for real traces in [Ebi92]. Its generalization to complex traces seems to be without any additional difficulty. Besides, the most well-known characterizations of recognizable languages use the notion of finite automata. Recognizable word languages are languages which are accepted by (non-deterministic) Büchi automata or by deterministic Muller automata. Asynchronous (cellular) automata [Zie87, Zie89] provide distributed acceptors for recognizable languages of finite traces. With a suitable Büchi like condition, non-deterministic asynchronous (cellular) automata accept exactly the recognizable languages of real traces [GP92] and may be easily extended to accept complex trace languages. Hence, the main open problem in this field is to obtain a characterization of recognizable languages of infinite traces with an appropriate model of finite deterministic automata.

Acknowledgements: We thank Anca Muscholl for fruitful discussions and for the simple example before Theorem 2.14.

References

[AR88] I.J. Aalbersberg and G. Rozenberg. Theory of traces. Theoret. Comput. Sci., 60:1–82, 1988.

[Arn85] A. Arnold. A syntactic congruence for rational ω-languages. Theoret. Comput. Sci., 39:333–335, 1985.

[BMP90] P. Bonizzoni, G. Mauri, and G. Pighizzini. About infinite traces. In V. Diekert, editor, Proceedings of the ASMICS workshop Free Partially Commutative Monoids, Kochel am See (Germany) 1989, Report TUM-I9002, Technical University of Munich, pages 1–10, 1990.

[Büc62] R. Büchi. On a decision method in restricted second order arithmetic. In Proc. Internat. Congress on Logic, Methodology and Philosophy, pages 1–11. Standford University Press, 1962.

[CF69] P. Cartier and D. Foata. Problèmes combinatoires de commutation et réarrangements. Lecture Notes in Mathematics 85. Springer, Berlin-Heidelberg-New York, 1969.

[CP85] R. Cori and D. Perrin. Automates et commutations partielles. R.A.I.R.O.-Informatique Théorique et Applications, 19:21–32, 1985.

[DGP91] V. Diekert, P. Gastin, and A. Petit. Recognizable complex trace languages. In A. Tarlecki, editor, Proceedings of the 16th Symposium on Mathematical Foundations of Computer Science (MFCS’91), Kazimierz Dolny (Poland) 1991, Lecture Notes in Computer Science 520, pages 131–140. Springer, Berlin-Heidelberg-New York, 1991.

[Die90] V. Diekert. Combinatorics on Traces. Lecture Notes in Computer Science 454. Springer, Berlin-Heidelberg-New York, 1990.

[Die91] V. Diekert. On the concatenation of infinite traces. In C. Choffrut et al., editors, Proceedings of the 8th Annual Symposium on Theoretical Aspects of Computer Science (STACS’91), Hamburg (Germany) 1991, Lecture Notes in Computer Science 480, pages 105–117. Springer, Berlin-Heidelberg-New York, 1991.

[Ebi92] W. Ebinger. On logical definability of infinite trace languages. In V. Diekert et al., editors, Proceedings ASMICS Workshop Infinite Traces, Tübingen (Germany) 1992, Bericht 4/92, Fakultät Informatik, Universität Stuttgart, 1992. This volume pages 106–122.

[Fli74] M. Fliess. Matrices de Hankel. J. Math. Pures et Appl., 53:197–224, 1974.

[FR82] M.P. Flé and G. Roucairol. On the serializability of iterated transactions. In Proceedings ACM SIGACT-SIGOPS, Symposium on Principles of Distr. Comp., Ottawa (Canada) 1982, pages 194–200, 1982.

[Gas90] P. Gastin. Infinite traces. In I. Guessarian, editor, Proceedings of the Spring School of Theoretical Computer Science on Semantics of Systems of Concurrent Processes, Lecture Notes in Computer Science 469, pages 277–308. Springer, Berlin-Heidelberg-New York, 1990.

[Gas91] P. Gastin. Recognizable and rational trace languages of finite and infinite traces. In C. Choffrut et al., editors, Proceedings of the 8th Annual Symposium on Theoretical Aspects of Computer Science (STACS’91), Hamburg (Germany))1991, Lecture Notes in Computer Science 480, pages 89–104. Springer, Berlin-Heidelberg-New York, 1991.

[GP92] P. Gastin and A. Petit. Asynchronous cellular automata for infinite traces. In W. Kuich, editor, Proceedings of the 19th International Colloquium on Automata Languages and Programming (ICALP’92), Vienna (Austria) 1992, Lecture Notes in Computer Science. Springer, Berlin-Heidelberg-New York, 1992. Also available as Tech. Rep. 91-68, LITP, Université Paris 6, France, 1991.

[GPZ91] P. Gastin, A. Petit, and W. Zielonka. A Kleene theorem for infinite trace languages. In J. Leach Albert et al., editors, Proceedings of the 18th International Colloquium on Automata Languages and Programming (ICALP’91), Madrid (Spain) 1991, Lecture Notes in Computer Science 510, pages 254–266. Springer, Berlin-Heidelberg-New York, 1991.

[GR91] P. Gastin and B. Rozoy. The poset of infinitary traces. Technical Report, LITP 91.24, Université de Paris 6, 1991. To appear in Theoret. Comp. Sci.

[Gra81] R. Graham. Rudiments of Ramsey theory. Regional Conference Series in Mathematics 45, 1981.

[Kwi90] M. Kwiatkowska. A metric for traces. Imform. Proc. Letters, 35:129–135, 1990.

[Maz77] A. Mazurkiewicz. Concurrent program schemes and their interpretations. DAIMI Rep. PB 78, Aarhus University, Aarhus, 1977.

[Maz87] A. Mazurkiewicz. Trace theory. In W. Brauer et al., editors, Petri Nets, Applications and Relationship to other Models of Concurrency, Lecture Notes in Computer Science 255, pages 279–324. Springer, Berlin-Heidelberg-New York, 1987.

[Mét86] Y. Métivier. Une condition suffisante de reconnaissabilité dans un monoïde partiellement commutatif. R.A.I.R.O.- Informatique Théorique et Applications, 20:121–127, 1986.

[MR91] Y. Métivier and B. Rozoy. On the star operation in free partially commutative monoids. International Journal of Foundations of Computer Science, 2:257–265, 1991.

[Och85] E. Ochmanski. Regular behaviour of concurrent systems. Bull. of the European Association for Theoretical Computer Science (EATCS), 27:56–67, Oct 1985.

[Och90] E. Ochmanski. Notes on a star mystery. Bull. of the European Association for Theoretical Computer Science (EATCS), 40:252–257, Feb 1990.

[Per89] D. Perrin. Partial commutations. In G. Ausiello et al., editors, Proceedings of the 16th International Colloquium on Automata, Languages and Programming (ICALP’89), Stresa (Italy) 1989, Lecture Notes in Computer Science 372, pages 637–651. Springer, Berlin-Heidelberg-New York, 1989.

[PP91] D. Perrin and J.E. Pin. Mots Infinis. Technical Report, LITP 91.06, Université de Paris 6, 1991.

[Sak87] J. Sakarovitch. On regular trace languages. Theoret. Comput. Sci., 52:59–75, 1987.

[Tho90] W. Thomas. On logical definability of trace languages. In V. Diekert, editor, Proceedings of the ASMICS workshop Free Partially Commutative Monoids, Kochel am See, Oktober 1989, Report TUM-I9002, Technical University of Munich, pages 1–10, 1990.

[Zie87] W. Zielonka. Notes on finite asynchronous automata. R.A.I.R.O.-Informatique Théorique et Applications, 21:99– 135, 1987.

[Zie89] W. Zielonka. Safe executions of recognizable trace languages by asynchronous automata. In A. R. Mayer et al., editors, Proceedings Symposium on Logical Foundations of Computer Science, Logic at Botik ’89, Pereslavl-Zalessky (USSR) 1989, Lecture Notes in Computer Science 363, pages 278–289. Springer, Berlin-Heidelberg-New York, 1989.

270 Open problems 271

Open problems in trace theory proposed by

Giovanni Pighizzini and Nicoletta Sabadini

1 Determinization of asynchronous automata

A very surprising result obtained by W. Zielonka [Zie87] is the solution of the following problem:

Problem 1 Given a deterministic automaton over the free partially commutative monoid find a deterministic asynchronous automaton accepting the same trace language.

The proof given by Zielonka is rather complicated and it seems difficult to simplify it, despite all efforts, e.g. [CM88].

The characterization of the class of recognizable trace languages given by Ochmański [Och85] suggests a different approch to Problem 1 similar to the usual proof of Kleene’s Theorem [Pig92]. Unfortunately, the automaton so obtained is nondeterministic. Even if the possibility of obtaining an equivalent deterministic asynchronous automaton is a consequence of Zielonka’s result, up to date there is not any direct construction.

Thus, we state the following problem:

Open problem 1 Find a “new” strategy to transform nondeterministic asynchronous automata in deterministic asynchronous automata, without using Zielonka’s proof.

We briefly point out that the main difficult of Zielonka’s result is to obtain a distributed automaton starting from a monoid automaton, in such a way that there is a link between their states.

Our open problem seems to be easier since the input is already a distributed automaton; in spite of this, similar technical problems arise.

Similar considerations can be formulated for asynchronous cellular automata.

2 Probabilistic asynchronous automata

As a second open problem, we still propose the generalization of Zielonka’s Theorem to probabilistic asynchronous automata.

Probabilistic asynchronous automata were introduced in [MS89]. In [JPS90], the following problem were positively solved in the case of concurrent alphabets with acyclic dependency graph.

Open problem 2 Given a concurrent alphabet (Σ, C), does the class of behaviours of F (Σ, C)–probabilistic asynchronous automata coincide with the class of behaviours of probabilistic asynchronous automata over (Σ, C) ?

In the general case this problem is still open.

3 Extensions of the notion of infinite trace

An extension of the notion of finite traces was recently proposed by A. Arnold [Arn91], by considering pomsets without self–concurrency. In this extension the concurrency relation is not fixed a priori. A similar extension in the infinite case could be useful to describe infinite behaviours of concurrent systems. So, we state the following problem:

Open problem 3 Extend the theory of infinite traces to pomsets without self–concurrency, giving a suitable notion of recognizing devices.

4 The equivalence and the inclusion problems for k–ambiguous regular trace languages

The equivalence problem (inclusion problem, resp.) for a class C of trace languages consists in deciding if L′ = L′′ (L′ ⊆ L′′, resp.), where L′ and L′′ are languages in the class C.

Let R_{k}(Σ, C) denotes the class of regular trace languages over the concurrent alphabet (Σ, C) with degree of ambiguity k [BMS82b] and R_{0}(Σ, C) the class of recognizable trace languages. We briefly recall that

R_{0}(Σ, C) ⊆ R_{1}(Σ, C) ⊆ … ⊆ R_{k}(Σ, C) ⊆ … ⊆ R(Σ, C),

where R(Σ, C) is the class of regular trace languages over (Σ, C).

It is known that for the class R_{0}(Σ, C) the equivalence problem is decidable for all concurrent alphabets, while for the class R(Σ, C) it is decidable if and only if the concurrency relation C is transitive [BMS82a, AH87]. In [BPS88], it was proved that there exists a concurrent alphabet (Σ, C) with nontransitive concurrency relation such that the equivalence problem for R_{1}(Σ, C) is decidable. This result has been recently extended in [Var91] proving that for every concurrent alphabet (Σ, C), the equivalence problem for R_{1}(Σ, C) is decidable.

Up to date, there is none result concerning the classes R_{k}(Σ, C) for k ≥ 2.

Open problem 4 For every k ≥ 2, characterize the class of concurrent alphabets (Σ, C) such that the equivalence problem for trace languages in R_{k}(Σ, C) is decidable.

For the class R(Σ, C) of regular trace languages, the inclusion problem is decidable if and only if the independency relation C is transitive [Sak90]. Moreover, the same problem for R_{0}(Σ, C) is decidable for every concurrent alphabet.

None result is known for the class R_{1}(Σ, C) of unambiguous regular trace languages and for k–ambiguous regular trace languages.

Open problem 5 For every k ≥ 1, characterize the class of concurrent alphabets (Σ, C) such that the inclusion problem for trace languages in R_{k}(Σ, C) is decidable.

References

[AH87] IJ. Aalbersberg and H. Hoogeboom. Decision problems for regular trace languages. In Proc. 14th ICALP, Lecture Notes in Computer Science 267, pages 251–259, 1987.

[Arn91] A. Arnold. An extension of the notions of traces and of asynchronous automata. RAIRO Inf. Theor., 25:355–393, 1991.

[BMS82a] A. Bertoni, G. Mauri, and N. Sabadini. Equivalence and membership problems for regular trace languages. In Proc. 9th ICALP, Lecture Notes in Computer Science 140, pages 61–71, 1982.

[BMS82b] A. Bertoni, G. Mauri, and N. Sabadini. A hierarchy of regular trace languages and some combinatorial applications. In Proc. 2nd World Conference on Mathematics at the Service of Men, pages 146–153, Las Palmas, 1982.

[BPS88] D. Bruschi, G. Pighizzini, and N. Sabadini. On the existence of the minimum asynchronous automaton and on decision problems for unambiguous regular trace languages. In Proc. 5th STACS, Lecture Notes in Computer Science 294, pages 334–346, 1988. To appear in Information and Computation.

[CM88] R. Cori and Y. Métivier. Approximation of a trace, asynchronous automata and the ordering of events in a distributed system. In Proc. 15th ICALP, Lecture Notes in Computer Science 317, pages 147–161, 1988.

[JPS90] S. Jesi, G. Pighizzini, and N. Sabadini. Probabilistic asynchronous automata. In Proceedings of the workshop: Free partially commutative monoids, Institüt für Informatic – Technische Universität München – TUM–I9002, pages 99–114, 1990.

[MS89] P. Massazza and N. Sabadini. Some applications and techniques for generating functions. In Proc. CAAP 89, Lecture Notes in Computer Science 351, pages 321–336, 1989.

[Och85] E. Ochmański. Regular behaviour of concurrent systems. EATCS Bullettin, 27:56–67, 1985.

[Pig92] G. Pighizzini. Synthesis of nondeterministic asynchronous automata. 1992. These proceedings.

[Sak90] J. Sakarovitch. The “last” decision problem on rational trace languages. In Proceedings of the workshop: Free partially commutative monoids, Institüt für Informatic – Technische Universität München – TUM–I9002, pages 168–171, 1990.

[Var91] S. Varricchio. On the decidability of the equivalence problem for partially commutative rational power series, 1991. Manuscript.

[Zie87] W. Zielonka. Notes on finite asynchronous automata. RAIRO Inf. Theor., 21:99–135, 1987.