The Complexity of Separation for Levels in Concatenation Hierarchies

LIPICS - Leibniz International Proceedings in Informatics, Nov 2018

We investigate the complexity of the separation problem associated to classes of regular languages. For a class C, C-separation takes two regular languages as input and asks whether there exists a third language in C which includes the first and is disjoint from the second. First, in contrast with the situation for the classical membership problem, we prove that for most classes C, the complexity of C-separation does not depend on how the input languages are represented: it is the same for nondeterministic finite automata and monoid morphisms. Then, we investigate specific classes belonging to finitely based concatenation hierarchies. It was recently proved that the problem is always decidable for levels 1/2 and 1 of any such hierarchy (with inefficient algorithms). Here, we build on these results to show that when the alphabet is fixed, there are polynomial time algorithms for both levels. Finally, we investigate levels 3/2 and 2 of the famous Straubing-Th�rien hierarchy. We show that separation is PSpace-complete for level 3/2 and between PSpace-hard and EXPTime for level 2.

A PDF file should load here. If you do not see its contents the file may be temporarily unavailable at the journal website or you do not have a PDF plug-in installed and enabled in your browser.

Alternatively, you can download the file locally and open with any standalone PDF reader:

http://drops.dagstuhl.de/opus/volltexte/2018/9946/pdf/LIPIcs-FSTTCS-2018-47.pdf

The Complexity of Separation for Levels in Concatenation Hierarchies

F S T T C S The Complexity of Separation for Levels in Concatenation Hierarchies Thomas Place LaBRI Bordeaux University 0 France 0 Marc Zeitoun 0 0 LaBRI Bordeaux University , France We investigate the complexity of the separation problem associated to classes of regular languages. For a class C, C-separation takes two regular languages as input and asks whether there exists a third language in C which includes the first and is disjoint from the second. First, in contrast with the situation for the classical membership problem, we prove that for most classes C, the complexity of C-separation does not depend on how the input languages are represented: it is the same for nondeterministic finite automata and monoid morphisms. Then, we investigate specific classes belonging to finitely based concatenation hierarchies. It was recently proved that the problem is always decidable for levels 1/2 and 1 of any such hierarchy (with inefficient algorithms). Here, we build on these results to show that when the alphabet is fixed, there are polynomial time algorithms for both levels. Finally, we investigate levels 3/2 and 2 of the famous Straubing-Thérien hierarchy. We show that separation is PSpace-complete for level 3/2 and between PSpace-hard and EXPTime for level 2. 2012 ACM Subject Classification Theory of computation → Formal languages and automata theory Related Version A full version of the paper is available at https://arxiv.org/abs/1810. 09287. Funding Both authors acknowledge support from the DeLTA project (ANR-16-CE40-0007). and phrases Regular languages; separation; concatenation hierarchies; complexity Introduction For more than 50 years, a significant research effort in theoretical computer science was made to solve the membership problem for regular languages. This problem consists in determining whether a class of regular languages is decidable, that is, whether there is an algorithm inputing a regular language and outputing ‘yes’ if the language belongs to the investigated class, and ‘no’ otherwise. Many results were obtained in a long and fruitful line of research. The most prominent one is certainly Schützenberger’s theorem [19], which gives such an algorithm for the class of star-free languages. For most interesting classes also, we know precisely the computational cost of the membership problem. As can be expected, this cost depends on the way the input language is given. Indeed, there are several ways to input a regular language. For instance, it can be given by a nondeterministic finite automaton (NFA), or, alternately, by a morphism into a finite monoid. While obtaining an NFA representation from a morphism into a monoid has only a linear cost, the converse direction is much more expensive: from an NFA with n states, the smallest monoid recognizing the same language may have an exponential number of elements (the standard construction yields 2n2 elements). This explains why the complexity of the membership problem depends on the representation of the input. For instance, for the class of star-free languages, it is PSpace-complete if one starts from NFAs (and actually, even from DFAs [2]) while it is NL when starting from monoid morphisms. Recently, another problem, called separation, has replaced membership as the cornerstone in the investigation of regular languages. It takes as input two regular langages instead of one, and asks whether there exists a third language from the class under investigation including the first input language and having empty intersection with the second one. This problem has served recently as a major ingredient in the resolution of difficult membership problems, such as the so-called dot-depth two problem [16] which remained open for 40 years (see [13, 18, 6] for recent surveys on the topic). Dot-depth two is a class belonging to a famous concatenation hierarchy which stratifies the star-free languages: the dot-depth [1]. A specific concatenation hierarchy is built in a generic way. One starts from a base class (level 0 of the hierarchy) and builds increasingly growing classes (called levels and denoted by 1/2, 1, 3/2, 2, . . . ) by alternating two standard closure operations: polynomial and Boolean closure. Concatenation hierarchies account for a significant part of the open questions in this research area. The state of the art regarding separation is captured by only three results [17, 9]: in finitely based concatenation hierarchies (i.e. those whose basis is a finite class) levels 1/2, 1 and 3/2 have decidable separation. Moreover, using specific transfer results [15], this can be pushed to the levels 3/2 and 2 for the two most famous finitely based hierarchies: the dot-depth [1] and the Straubing-Thérien hierarchy [21, 22]. Unlike the situation for membership and despite these recent decidability results for separability in concatenation hierarchies, the complexity of the problems and of the corresponding algorithms has not been investigated so far (except for the class of piecewise testable languages [3, 11, 5], which is level 1 in the Straubing-Thérien hierarchy). The aim of this paper is to establish such complexity results. Our contributions are the following: We present a generic reduction, which shows that for many natural classes, the way the input is given (by NFAs or finite monoids) has no impact on the complexity of the separation problem. This is proved using two LogSpace reductions from one problem to the other. This situation is surprising and opposite to that of the membership problem, where an exponential blow-up is unavoidable when going from NFAs to monoids. Building on the results of [17], we show that when the alphabet is fixed, there are polynomial time algorithms for levels 1/2 and 1 in any finitely based hierarchy. We investigate levels 3/2 and 2 of the famous Straubing-Thérien hierarchy, and we show that separation is PSpace-complete for level 3/2 and between PSpace-hard and EXPTime for level 2. The upper bounds are based on the results of [17] while the lower bounds are based on independent reductions. Organization. In Section 2, we give preliminary terminology on the objects investigated in the paper. Sections 3, 4 and 5 are then devoted to the three above points. Due to space limitations, many proofs are postponed to the full version of the paper. 2 Preliminaries In this section, we present the key objects of this paper. We define words and regular languages, classes of languages, the separation problem and finally, concatenation hierarchies. 2.1 Words and regular languages An alphabet is a finite set A of symbols, called letters. Given some alphabet A, we denote by A+ the set of all nonempty finite words and by A∗ the set of all finite words over A (i.e., A∗ = A+ ∪ {ε}). If u ∈ A∗ and v ∈ A∗ we write u · v ∈ A∗ or uv ∈ A∗ for the concatenation of u and v. A language over an alphabet A is a subset of A∗. Abusing terminology, if u ∈ A∗ is some word, we denote by u the singleton language {u}. It is standard to extend concatenation to languages: given K, L ⊆ A∗, we write KL = {uv | u ∈ K and v ∈ L}. Moreover, we also consider marked concatenation, which is less standard. Given K, L ⊆ A∗, a marked concatenation of K with L is a language of the form KaL, for some a ∈ A. We consider regular languages, which can be equivalently defined by regular expressions, nondeterministic finite automata (NFAs), finite monoids or monadic second-order logic (MSO). In the paper, we investigate the separation problem which takes regular languages as input. Since we are focused on complexity, how we represent these languages in our inputs matters. We shall consider two kinds of representations: NFAs and monoids. Let us briefly recall these objects and fix the terminology (we refer the reader to [7] for details). NFAs. An NFA is a tuple A = (A, Q, δ, I, F ) where A is an alphabet, Q a finite set of states, δ ⊆ Q × A × Q a set of transitions, I ⊆ Q a set of initial states and F ⊆ Q a set of final states. The language L(A) ⊆ A∗ consists of all words labeling a run from an initial state to a final state. The regular languages are exactly those which are recognized by an NFA. Finally, we write “DFA” for deterministic finite automata, which are defined in the standard way. Monoids. We turn to the algebraic definition of regular languages. A monoid is a set M endowed with an associative multiplication (s, t) 7→ s · t (also denoted by st) having a neutral element 1M , i.e., such that 1M · s = s · 1M = s for every s ∈ M . An idempotent of a monoid M is an element e ∈ M such that ee = e. Observe that A∗ is a monoid whose multiplication is concatenation (the neutral element is ε). Thus, we may consider monoid morphisms α : A∗ → M where M is an arbitrary monoid. Given such a morphism, we say that a language L ⊆ A∗ is recognized by α when there exists a set F ⊆ M such that L = α−1(F ). It is well-known that the regular languages are also those which are recognized by a morphism into a finite monoid. When representing a regular language L by a morphism into a finite monoid, one needs to give both the morphism α : A∗ → M (i.e., the image of each letter) and the set F ⊆ M such that L = α−1(F ). 2.2 Classes of languages and separation A class of languages C is a correspondence A 7→ C(A) which, to an alphabet A, associates a set of languages C(A) over A. I Remark. When two alphabets A, B satisfy A ⊆ B, the definition of classes does not require C(A) and C(B) to be comparable. In fact, it may happen that a particular language L ⊆ A∗ ⊆ B∗ belongs to C(A) but not to C(B) (or the opposite). For example, we may consider the class C defined by C(A) = {∅, A∗} for every alphabet A. When A ( B, we have A∗ ∈ C(A) while A∗ 6∈ C(B). We say that C is a lattice when for every alphabet A, we have ∅, A∗ ∈ C(A) and C(A) is closed under finite union and finite intersection: for any K, L ∈ C(A), we have K ∪ L ∈ C(A) and K ∩ L ∈ C(A). Moreover, a Boolean algebra is a lattice C which is additionally closed under complement: for any L ∈ C(A), we have A∗ \ L ∈ C(A). Finally, a class C is quotienting if it is closed under quotients. That is, for every alphabet A, L ∈ C(A) and word u ∈ A∗, the following properties hold: u−1L d=ef {w ∈ A∗ | uw ∈ L} and Lu−1 d=ef {w ∈ A∗ | wu ∈ L} both belong to C(A). All classes that we consider in the paper are (at least) quotienting lattices consisting of regular languages. Moreover, some of them satisfy an additional property called closure under inverse image. Recall that A∗ is a monoid for any alphabet A. We say that a class C is closed under inverse image if for every two alphabets A, B, every monoid morphism α : A∗ → B∗ and every language L ∈ C(B), we have α−1(L) ∈ C(A). A quotienting lattice (resp. quotienting Boolean algebra) closed under inverse image is called a positive variety (resp. variety). Separation. Consider a class of languages C. Given an alphabet A and two languages L1, L2 ⊆ A∗, we say that L1 is C-separable from L2 when there exists a third language K ∈ C(A) such that L1 ⊆ K and L2 ∩ K = ∅. In particular, K is called a separator in C. The C-separation problem is now defined as follows: Input: An alphabet A and two regular languages L1, L2 ⊆ A∗. Output: Is L1 C-separable from L2 ? I Remark. Separation generalizes the simpler membership problem, which asks whether a single regular language belongs to C. Indeed L ∈ C if and only if L is C-separable from A∗ \ L (which is also regular and computable from L). Most papers on separation are mainly concerned about decidability. Hence, they do not go beyond the above presentation of the problem (see [3, 16, 12, 17] for example). However, this paper specifically investigates complexity. Consequently, we shall need to be more precise and take additional parameters into account. First, it will be important to specify whether the alphabet over which the input languages is part of the input (as above) or a constant. When considering separation for some fixed alphabet A, we shall speak of “C(A)-separation”. When the alphabet is part of the input, we simply speak of “C-separation”. Another important parameter is how the two input languages are represented. We shall consider NFAs and monoids. We speak of separation for NFAs and separation for monoids. Note that one may efficiently reduce the latter to the former. Indeed, given a language L ⊆ A∗ recognized by some morphism α : A∗ → M , it is simple to efficiently compute a NFA with |M | states recognizing L (see [7] for example). Hence, we have the following lemma. I Lemma 1. For any class C, there is a LogSpace reduction from C-separation for monoids to C-separation for NFAs. Getting an efficient reduction for the converse direction is much more difficult since going from NFAs (or even DFAs) to monoids usually involves an exponential blow-up. However, we shall see in Section 3 that for many natural classes C, this is actually possible. 2.3 Concatenation hierarchies We now briefly recall the definition of concatenation hierarchies. We refer the reader to [18] for a more detailed presentation. A particular concatenation hierarchy is built from a starting class of languages C, which is called its basis. In order to get robust properties, we restrict C to be a quotienting Boolean algebra of regular languages. The basis is the only parameter in the construction. Once fixed, the construction is generic: each new level is built from the previous one by applying generic operators: either Boolean closure, or polynomial closure. Let us first define these two operators. Definition. Consider a class C. We denote by Bool(C) the Boolean closure of C: for every alphabet A, Bool(C)(A) is the least set containing C(A) and closed under Boolean operations. Moreover, we denote by Pol(C) the polynomial closure of C: for every alphabet A, Pol(C)(A) is the least set containing C(A) and closed under union and marked concatenation (if K, L ∈ Pol(C)(A) and a ∈ A, then K ∪ L, KaL ∈ Pol(C)(A)). Consider a quotienting Boolean algebra of regular languages C. The concatenation hierarchy of basis C is defined as follows. Languages are classified into levels of two kinds: full levels (denoted by 0, 1, 2,. . . ) and half levels (denoted by 1/2, 3/2, 5/2,. . . ). Level 0 is the basis (i.e., C) and for every n ∈ N, The half level n + 1/2 is the polynomial closure of the previous full level, i.e., of level n. The full level n + 1 is the Boolean closure of the previous half level, i.e., of level n + 1/2. 0 P ol 1/2 Bool 1 P ol 3/2 Bool 2 P ol 5/2 We write 12 N = {0, 1/2, 1, 2, 3/2, 3, . . . } for the set of all possible levels in a concatenation hierarchy. Moreover, for any basis C and n ∈ 21 N, we write C[n] for level n in the concatenation hierarchy of basis C. It is known that every half-level is a quotienting lattice and every full level is a quotienting Boolean algebra (see [18] for a recent proof). We are interested in finitely based concatenation hierarchies: if C is the basis, then C(A) is finite for every alphabet A. Indeed, it was shown in [17] that for such hierarchies separation is always decidable for the levels 1/2 and 1 (in fact, while we do not discuss this in the paper, this is also true for level 3/2, see [9] for a preliminary version). In Section 4, we build on the results of [17] and show that when the alphabet is fixed, this can be achieved in polynomial time for both levels 1/2 and 1. Moreover, we shall also investigate the famous Straubing-Thérien hierarchy in Section 5. Our motivation for investigating this hierarchy in particular is that the results of [17] can be pushed to levels 3/2 and 2 in this special case. 3 Handling NFAs In this section, we investigate how the representation of input languages impact the complexity of separation. We prove that for many natural classes C (including most of those considered in the paper), C-separation has the same complexity for NFAs as for monoids. Because of these results, we shall be able to restrict ourselves to monoids in later sections. I Remark. This result highlights a striking difference between separation and the simpler membership problem. For most classes C, C-membership is strictly harder for NFAs than for monoids. This is because when starting from a NFA, typical membership algorithms require to either determinize A or compute a monoid morphism recognizing L(A) which involves an exponential blow-up in both cases. Our results show that the situation differs for separation. We already have a generic efficient reduction from C-separation for monoids to C-separation for NFAs (see Lemma 1). Here, we investigate the opposite direction: given some class C, is it possible to efficiently reduce C-separation for NFAs to C-separation for monoids ? As far as we know, there exists no such reduction which is generic to all classes C. I Remark. There exists an inefficient generic reduction from separation for NFAs to the separation for monoids. Given as input two NFAs A1, A2, one may compute monoid morphisms recognizing L(A1) and L(A2). This approach is not satisfying as it involves an exponential blow-up: we end-up with monoids Mi of size 2|Qi|2 where Qi is the set of states of Ai. Here, we present a set of conditions applying to a pair of classes (C, D). When they are satisfied, there exists an efficient reduction from C-separation for NFAs to D-separation for monoids. By themselves, these conditions are abstract. However, we highlight two concrete applications. First, for every positive variety C, the pair (C, C) satisfies the conditions. Second, for every finitely based concatenation hierarchies of basis C, there exists another finite basis D such that for every n ∈ 12 N, the pair (C[n], D[n]) satisfies the conditions We first introduce the notions we need to present the reduction and the conditions required to apply it. Then, we state the reduction itself and its applications. 3.1 Generic theorem We fix a special two letter alphabet E = {0, 1}. For the sake of improved readability, we abuse terminology and assume that when considering an arbitrary alphabet A, it always has empty intersection with E . This is harmless as we may work up to bijective renaming. We exhibit conditions applying to a pair of classes (C, D). Then, we prove that they imply the existence of an efficient reduction from C-separation for NFAs to D-separation for monoids. This reduction is based on a construction which takes as input a NFA A (over some arbitrary alphabet A) and builds a modified version of the language L(A) (over A ∪ E ) which is recognized by a “small” monoid. Our conditions involve two kinds of hypotheses: 1. First, we need properties related to inverse image: “D must be an an extension of C”. 2. The construction is parametrized by an object called “tagging”. We need an algorithm which builds special taggings (with respect to D) efficiently. We now make these two notions more precise. Let us start with extension. Extensions. Consider two classes C and D. We say that D is an extension of C when for every alphabet A, the two following conditions hold: If γ : (A ∪ E )∗ → A∗ is the morphism defined by γ(a) = a for a ∈ A and γ(b) = ε for b ∈ E , then for every K ∈ C(A), we have γ−1(K) ∈ D(A ∪ E ). For every u ∈ E ∗, if λu : A∗ → (A ∪ E )∗ is the morphism defined by λu(a) = au for a ∈ A, then for every K ∈ D(A ∪ E ), we have λu−1(K) ∈ C(A). Positive varieties give an important example of extension. Since they are closed under inverse image, it is immediate that for every positive variety C, C is an extension of itself. Taggings. A tagging is a pair P = (τ : E ∗ → T, G) where τ is a morphism into a finite monoid and G ⊆ T . We call |G| the rank of P and |T | its size. Moreover, given some NFA A = (A, Q, δ, I, F ), P is compatible with A when the rank |G| is larger than |δ|. For our reduction, we shall require special taggings. Consider a class D and a tagging P = (τ : E ∗ → T, G). We say that P fools D when, for every alphabet A and every morphism α : (A ∪ E )∗ → M into a finite monoid M , if all languages recognized by α belong to Bool(D)(A ∪ E ), then, there exists s ∈ M , such that for every t ∈ G, we have wt ∈ E ∗ which satisfies α(wt) = s and τ (wt) = t. Our reduction requires an efficient algorithm for computing taggings which fool the output class D. Specifically, we say that a class D is smooth when, given as input k ∈ N, one may compute in LogSpace (with respect to k) a tagging of rank at least k which fools D. Main theorem. We may now state our generic reduction theorem. The statement has two variants depending on whether the alphabet is fixed or not. I Theorem 2. Let C, D be quotienting lattices such that D is smooth and extends C. Then the two following properties hold: There is a LogSpace reduction from C-separation for NFAs to D-separation for monoids. For every fixed alphabet A, there is a LogSpace reduction from C(A)-separation for NFAs to D(A ∪ E )-separation for monoids. We have two main applications of Theorem 2 which we present at the end of the section. Let us first describe the reduction. As we explained, we use a construction building a language recognized by a “small” monoid out of an input NFA and a compatible tagging. Consider a NFA A = (A, Q, δ, I, F ) and let P = (τ : E ∗ → T, G) be a compatible tagging (i.e. |δ| ≤ |G|). We associate a new language L[A, P ] over the alphabet A ∪ E and show that one may efficiently compute a recognizing monoid whose size is polynomial with respect to |Q| and the rank of P (i.e |G|). The construction involves two steps. We first define an intermediary language K[A, P ] over the alphabet A × T and then define L[A, P ] from it. We define K[A, P ] ⊆ (A × T )∗ as the language recognized by a new NFA A[P ] which is built by relabeling the transitions of A. Note that the definition of A[P ] depends on arbitrary linear orders on G and δ. We let A[P ] = (A × T, Q, δ[P ], I, F ) where δ[P ] is obtained by relabeling the transitions of A as follows. Given i ≤ |δ|, if (qi, ai, ri) ∈ δ is the i-th transition of A, we replace it with the transition (qi, (ai, ti), ri) ∈ δ[P ] where ti ∈ G is the i-th element of G (recall that |δ| ≤ |G| by hypothesis). I Remark. A key property of A[P ] is that, by definition, all transitions are labeled by distinct letters in A × T . This implies that K[A, P ] = L(A[P ]) is recognized by a monoid of size at most |Q|2 + 2. We may now define the language L[A, P ] ⊆ (A ∪ E )∗. Observe that we have a natural map μ : (AE ∗)∗ → (A × T )∗. Indeed, consider w ∈ (AE ∗)∗. Since A ∩ E = ∅ (recall that this is a global assumption), it is immediate that w admits a unique decomposition w = a1w1 · · · anwn with a1, . . . , an ∈ A and w1, . . . , wn ∈ E ∗. Hence, we may define μ(w) = (a1, P (w1)) · · · (an, P (wn)) ∈ (A × T )∗. Finally, we define, L[A, P ] = E ∗ · μ−1(K[A, P ]) ⊆ (A ∪ E )∗ We may now state the two key properties of L[A, P ] upon which Theorem 2 is based. It is recognized by a small monoid and the construction is connected to the separation. I Proposition 3. Given a NFA A = (A, Q, δ, I, F ) and a compatible tagging P of rank n, one may compute in LogSpace a monoid morphism α : (A ∪ E )∗ → M recognizing L[A, P ] and such that |M | ≤ n + |A| × n2 × (|Q|2 + 2). I Proposition 4. Let C, D be quotienting lattices such that D extends C. Consider two NFAs A1 and A2 over some alphabet A and let P be a compatible tagging that fools D. Then, L(A1) is C(A)-separable from L(A2) if and only if L[A1, P ] is D(A ∪ E )-separable from L[A2, P ]. Let us explain why these two propositions imply Theorem 2. Let C, D be quotienting lattices such that D is smooth and extends C. We show that the second assertion in the theorem holds (the first one is proved similarly). Consider two NFAs Ai = (A, Qj, δj, Ij, Fj) for j = 1, 2. We let k = max(|δ1|, |δ2|). Since D is smooth, we may compute (in LogSpace) a tagging P = (τ : E ∗ → T, G) of rank |G| ≥ k. Then, we may use Proposition 3 to compute (in LogSpace) monoid morphisms recognizing L[A1, P ] and L[A2, P ]. Finally, by Proposition 4, L(A1) is C(A)-separable from L(A2) if and only if L[A1, P ] is D(A ∪ E )-separable from L[A2, P ]. Altogether, this construction is a LogSpace reduction to D-separation for monoids which concludes the proof. 3.2 Applications We now present the two main applications of Theorem 2. We start with the most simple one positive varieties. Indeed, we have the following lemma. I Lemma 5. Let C be a positive variety. Then, C is an extension of itself. Moreover, if Bool(C) 6= REG, then C is smooth. That a positive variety is an extension of itself is immediate (one uses closure under inverse image). The difficulty is to prove smoothness. We may now combine Theorem 2 with Lemma 5 to get the following corollary. I Corollary 6. Let C be a positive variety such that Bool(C) 6= REG. There exists a LogSpace reduction from C-separation for NFAs to C-separation for monoids. Corollary 6 implies that for any positive variety C, the complexity of C-separation is the same for monoids and NFAs. We illustrate this with an example: the star-free languages. I Example 7. Consider the star-free languages (SF): for every alphabet A, SF(A) is the least set of languages containing all singletons {a} for a ∈ A and closed under Boolean operations and concatenation. It is folklore and simple to verify that SF is a variety. It is known that SF-membership is in NL for monoids (this is immediate from Schützenberger’s theorem [19]). On the other hand, SF-membership is PSpace-complete for NFAs. In fact, it is shown in [2] that PSpace-completeness still holds for deterministic finite automata (DFAs). For SF-separation, we may combine Corollary 6 with existing results to obtain that the problem is in EXPTime and PSpace-hard for both NFAs and monoids. Indeed, the EXPTime upper bounds is proved in [14] for monoids and we may lift it to NFAs with Corollary 6. Finally, the PSpace lower bound follows from [2]: SF-membership is PSpace-hard for DFAs. This yields that SF-separation is PSpace-hard for both DFAs and NFAs (by reduction from membership to separation which is easily achieved in LogSpace when starting from a DFA). Using Corollary 6 again, we get that SF-separation is PSpace-hard for monoids as well. J We turn to our second application: finitely based concatenation hierarchies. Consider a finite quotienting Boolean algebra C. We associate another finite quotienting Boolean algebra CE which we only define for alphabets of the form A ∪ E (this is harmless: CE is used as the output class of our reduction). Let A be an alphabet and consider the morphism γ : (A ∪ E )∗ → A∗ defined by γ(a) = a for a ∈ A and γ(0) = γ(1) = ε. We define, CE (A ∪ E ) = {γ−1(L) | L ∈ C(A)} It is straightforward to verify that CE remains a finite quotienting Boolean algebra. Moreover, we have the following lemma. I Lemma 8. Let C be a finite quotienting Boolean algebra. For every n ∈ 12 N, CE [n] is smooth and an extension of C[n]. In view of Theorem 2, we get the following corollary which provides a generic reduction for levels within finitely based hierarchies. I Corollary 9. Let C be a finite basis and n ∈ 21 N. There exists a LogSpace reduction from C[n]-separation for NFAs to CE [n]-separation for monoids. Generic upper bounds for low levels in finitely based hierarchies In this section, we present generic complexity results for the fixed alphabet separation problem associated to the lower levels in finitely based concatenation hierarchies. More precisely, we show that for every finite basis C and every alphabet A, C[1/2](A)- and C[1](A)-separation are respectively in NL and in P. These upper bounds hold for both monoids and NFAs: we prove them for monoids and lift the results to NFAs using the reduction of Corollary 9. I Remark. We do not present new proofs for the decidability of C[1/2]- and C[1]-separation when C is a finite quotienting Boolean algebra. These are difficult results which are proved in [17]. Instead, we recall the (inefficient) procedures which were originally presented in [17] and carefully analyze and optimize them in order to get the above upper bounds. For the sake of avoiding clutter, we fix an arbitrary finite quotienting Boolean algebra C and an alphabet A for the section. 4.1 Key sub-procedure The algorithms C[1/2](A)- and C[1](A)-separation presented in [17] are based on a common sub-procedure. This remains true for the improved algorithms which we present in the paper. In fact, this sub-procedure is exactly what we improve to get the announced upper complexity bounds. We detail this point here. Note that the algorithms require considering special monoid morphisms (called “C-compatible”) as input. We first define this notion. C-compatible morphisms. Since C is finite, one associates a classical equivalence ∼C defined on A∗. Given u, v ∈ A∗, we write u ∼C v if and only if u ∈ L ⇔ v ∈ L for all L ∈ C(A). Given w ∈ A∗, we write [w]C ⊆ A∗ for its ∼C-class. Since C is a finite quotienting Boolean algebra, ∼C is a congruence of finite index for concatenation (see [18] for a proof). Hence, the quotient A∗/∼C is a monoid and the map w 7→ [w]C a morphism. Consider a morphism α : A∗ → M into a finite monoid M . We say that α is C-compatible when there exists a monoid morphism s 7→ [s]C from M to A∗/∼C such that for every w ∈ A∗, we have [w]C = [α(w)]C. Intuitively, the definition means that α “computes” the ∼C-classes of words in A∗. The following lemma is used to compute C-compatible morphisms (note that the LogSpace bound holds because C and A is fixed). I Lemma 10. Given two morphisms recognizing regular languages L1, L2 ⊆ A∗ as input, one may compute in LogSpace a C-compatible morphism which recognizes both L1 and L2. In view of Lemma 10, we shall assume in this section without loss of generality that our input in separation for monoids is a single C-compatible morphism recognizing the two languages that need to be separated. Sub-procedure. Consider two C-compatible morphisms α : A∗ → M and β : A∗ → N . We say that a subset of N is good (for β) when it contains β(A∗) and is closed under multiplication. For every good subset S of N , we associate a subset of M × 2N . We then consider the problem of deciding whether specific elements belong to it (this is the sub-procedure used in the separation algorithms). I Remark. The set M × 2N is clearly a monoid for the componentwise multiplication. Hence we may multiply its elements and speak of idempotents in M × 2N . An (α, β, S)-tree is an unranked ordered tree. Each node x must carry a label lab(x) ∈ M × 2N and there are three possible kinds of nodes: Leaves: x has no children and lab(x) = (α(w), {β(w)}) for some w ∈ A∗. Binary: x has exactly two children x1 and x2. Moreover, if (s1, T1) = lab(x1) and (s2, T2) = lab(x2), then lab(x) = (s1s2, T ) with T ⊆ T1T2. S-Operation: x has a unique child y. Moreover, the following must be satisfied: 1. The label lab(y) is an idempotent (e, E) ∈ M × 2N . 2. lab(x) = (e, T ) with T ⊆ E · {t ∈ S | [e]C = [t]C ∈ S} · E. We are interested in deciding whether elements in M × 2N are the root label of some computation tree. Observe that computing all such elements is easily achieved with a least fixpoint procedure: one starts from the set of leaf labels and saturates this set with three operations corresponding to the two kinds of inner nodes. This is the approach used in [17] (actually, the set of all root labels is directly defined as a least fixpoint and (α, β, S)-trees are not considered). However, this is costly since the computed set may have exponential size with respect to |N |. Hence, this approach is not suitable for getting efficient algorithms. Fortunately, solving C[1/2](A)- and C[1](A)-separation does not require to have the whole set of possible root labels in hand. Instead, we shall only need to consider the elements (s, T ) ∈ M × 2N which are the root label of some tree and such that T is a singleton set. It turns out that these specific elements can be computed efficiently. We state this in the next theorem which is the key technical result and main contribution of this section. I Theorem 11. Consider two C-compatible morphisms α : A∗ → M and β : A∗ → N and a good subset S ⊆ N . Given s ∈ M and t ∈ N , one may test in NL with respect to |M | and |N | whether there exists an (α, β, S)-tree with root label (s, {t}). Theorem 11 is proved in the full version of the paper. We only present a brief outline which highlights two propositions about (α, β, S)-trees upon which the theorem is based. We first define a complexity measure for (α, β, S)-trees. Consider two C-compatible morphisms α : A∗ → M and β : A∗ → N as well as a good subset S ⊆ N . Given an (α, β, S)-tree T , we define the operational height of T as the greatest number h ∈ N such that T contains a branch with h S-operation nodes. Our first result is a weaker version of Theorem 11. It considers the special case when we restrict ourselves to (α, β, S)-trees whose operational heights are bounded by a constant. I Proposition 12. Let h ∈ N be a constant and consider two C-compatible morphisms α : A∗ → M and β : A∗ → N and a good subset S ⊆ N . Given s ∈ M and t ∈ N , one may test in NL with respect to |M | and |N | whether there exists an (α, β, S)-tree of operational height at most h and with root label (s, {t}). Our second result complements the first one: in Theorem 11, it suffices to consider (α, β, S)-trees whose operational heights are bounded by a constant (depending only on the class C and the alphabet A which are fixed here). Let us first define this constant. Given a finite monoid M , we define the J -depth of M as the greatest number h ∈ N such that one may find h pairwise distinct elements s1, . . . , sh ∈ M such that for every i < h, si+1 = xsiy for some x, y ∈ M I Remark. The term “J -depth” comes from the Green’s relations which are defined on any monoid [4]. We do not discuss this point here. Recall that the quotient set A∗/∼C is a monoid. Consequently, it has a J -depth. Our second result is as follows. I Proposition 13. Let h ∈ N be the J -depth of A∗/∼C. Consider two C-compatible morphisms α : A∗ → M and β : A∗ → N , and a good subset S ⊆ N . Then, for every (s, T ) ∈ M × 2N , the following properties are equivalent: 1. (s, T ) is the root label of some (α, β, S)-tree. 2. (s, T ) is the root label of some (α, β, S)-tree whose operational height is at most h. In view of Proposition 13, Theorem 11 is an immediate consequence of Proposition 12 applied in the special case when h is the J -depth of A∗/∼C and m = 1. We now combine Theorem 11 with the results of [17] to get the upper complexity bounds for C[1/2](A)- and C[1](A)-separation that we announced at the begging of the section. Application to C[1/2]. Let us first recall the connection between C[1/2]-separation and (α, β, S)-trees. The result is taken from [17]. I Theorem 14 ([17]). Let α : A∗ → M be a C-compatible morphism and F0, F1 ⊆ M . Moreover, let S = α(A∗) ⊆ M . The two following properties are equivalent: α−1(F0) is C[1/2]-separable from α−1(F1). for every s0 ∈ F0 and s1 ∈ F1, there exists no (α, α, S)-tree with root label (s0, {s1}). By Theorem 11 and the Immerman–Szelepcsényi theorem (which states that NL = co-NL), it is straightforward to verify that checking whether the second assertion in Theorem 14 holds can be done in NL with respect to |M |. Therefore, the theorem implies that C[1/2](A)separation for monoids is in NL. This is lifted to NFAs using Corollary 9. I Corollary 15. For every finite basis C and alphabet A, C[1/2](A)-separation is in NL for both NFAs and monoids. Application to C[1]. We start by recalling the C[1]-separation algorithm which is again taken from [17]. In this case, we consider an auxiliary sub-procedure which relies on (α, β, S)-trees. Consider a C-compatible morphism α : A∗ → M . Observe that M 2 is a monoid for the componentwise multiplication. We let β : A∗ → M 2 as the morphism defined by β(w) = (α(w), α(w)) for every w ∈ A∗. Clearly, β is C-compatible: given (s, t) ∈ M 2, it suffices to define [(s, t)]C = [s]C. Using (α, β, S)-trees, we define a procedure S 7→ Red(α, S) which takes as input a good subset S ⊆ M 2 (for β) and outputs a subset Red(α, S) ⊆ S. Red(α, S) = {(s, t) ∈ S | (s, {(t, s)}) ∈ M × 2M2 is the root label of an (α, β, S)-tree} ⊆ S It is straightforward to verify that Red(α, S) remains a good subset of M 2. We now have the following theorem which is taken from [17]. I Theorem 16 ([17]). Let α : A∗ → M be a morphism into a finite monoid and F0, F1 ⊆ M . Moreover, let S ⊆ M 2 be the greatest subset of α(A∗) × α(A∗) such that Red(α, S) = S. Then, the two following properties are equivalent: α−1(F0) is Bool(Pol(C))-separable from α−1(F1). for every s0 ∈ F0 and s1 ∈ F1, (s0, s1) 6∈ S. Observe that Theorem 11 implies that given an arbitrary good subset S of α(A∗) × α(A∗), one may compute Red(α, S) ⊆ S in P with respect to |M |. Therefore, the greatest subset S of α(A∗) × α(A∗) such that Red(α, S) = S can be computed in P using a greatest fixpoint algorithm. Consequently, Theorem 16 yields that C[1](A)-separation for monoids is in P. Again, this is lifted to NFAs using Corollary 9. I Corollary 17. For every finite basis C and alphabet A, C[1](A)-separation is in P for both NFAs and monoids. 5 The Straubing-Thérien hierarchy In this final section, we consider one of the most famous concatenation hierarchies: the Straubing-Thérien hierarchy [21, 22]. We investigate the complexity of separation for the levels 3/2 and 2. I Remark. Here, the alphabet is part of the input. For fixed alphabets, these levels can be handled with the generic results presented in the previous section (see Theorem 18 below). The basis of the Straubing-Thérien hierarchy is the trivial variety ST[0] defined by ST[0](A) = {∅, A∗} for every alphabet A. It is known and simple to verify (using induction) that all half levels are positive varieties and all full levels are varieties. The complexity of separation for the level one (ST[1]) has already been given a lot of attention. Indeed, this level corresponds to a famous class which was introduced independently from concatenation hierarchies: the piecewise testable languages [20]. It was shown independently in [3] and [11] that ST[1]-separation is in P for NFAs (and therefore for DFAs and monoids as well). Moreover, it was also shown in [5] that the problem is actually P-complete for NFAs and DFAs1. Additionally, it is shown in [3] that ST[1/2]-separation is in NL. In the paper, we are mainly interested in the levels ST[3/2] and ST[2]. Indeed, the Straubing-Thérien hierarchy has a unique property: the generic separation results of [17] apply to these two levels as well. Indeed, these are also the levels 1/2 and 1 in another finitely based hierarchy. Consider the class AT of alphabet testable languages. For every alphabet A, AT(A) is the set of all Boolean combinations of languages A∗aA∗ for a ∈ A. One may verify that AT is a variety and that AT(A) is finite for every alphabet A. Moreover, we have the following theorem which is due to Pin and Straubing [8] (see [18] for a modern proof). I Theorem 18 ([8]). For every n ∈ 21 N, we have AT[n] = ST[n + 1]. The theorem implies that ST[3/2] = AT[1/2] and ST[2] = AT[1]. Therefore, the results of [17] yield the decidability of separation for both ST[3/2] and ST[2] (the latter is the main result of [17]). As expected, this section investigates complexity for these two problems. 5.1 The level 3/2 We have the following tight complexity bound for ST[3/2]-separation. I Theorem 19. ST[3/2]-separation is PSpace-complete for both NFAs and monoids. The PSpace upper bound is proved by building on the techniques introduced in the previous section for handling the level 1/2 of an arbitrary finitely based hierarchies. Indeed, we have ST[3/2] = AT[1/2] by Theorem 18. However, let us point out that obtaining this upper bound requires some additional work: the results of Section 4 apply to the setting in which the alphabet is fixed, this is not the case here. In particular, this is why we end up with a PSpace upper bound instead of the generic NL upper presented in Corollary 15. The detailed proof is postponed to the full version of the paper. In this abstract, we focus on proving that ST[3/2]-separation is PSpace-hard. The proof is presented for NFAs: the result can then be lifted to monoids with Corollary 6 since ST[3/2] 1 Since ST[1] is a variety, P-completeness for ST[1]-separation can also be lifted to monoids using Corollary 6. is a positive variety. We use a LogSpace reduction from the quantified Boolean formula problem (QBF) which is among the most famous PSpace-complete problems. We first describe the reduction. For every quantified Boolean formula Ψ, we explain how to construct two languages LΨ and L0Ψ. It will be immediate from the presentation that given Ψ as input, one may compute NFAs for LΨ and L0Ψ in LogSpace. Then, we show that this construction is the desired reduction: Ψ is true if and only if LΨ is not ST[3/2]-separable from L0Ψ. Consider a quantified Boolean formula Ψ and let n be the number of variables it involves. We assume without loss of generality that Ψ is in prenex normal form and that the quantifierfree part of Ψ is in conjunctive normal form (QBF remains PSpace-complete when restricted to such formulas). That is, Ψ = Qn xn · · · Q1 x1 ϕ where x1 . . . xn are the variables of Ψ, Q1, . . . , Qn ∈ {∃, ∀} are quantifiers and ϕ is a quantifierfree Boolean formula involving the variables x1 . . . xn which is in conjunctive normal form. We describe the two regular languages LΨ, L0Ψ by providing regular expressions recognizing them. Let us first specify the alphabet over which these languages are defined. For each variable xi occurring in Ψ, we create two letters that we write xi and xi. Moreover, we let, X = {x1, . . . , xn} and X = {x1, . . . , xn} Additionally, our alphabet also contains the following letters: #1, . . . , #i, $. For 0 ≤ i ≤ n, we define an alphabet Bi. We have: B0 = X ∪ X and Bi = X ∪ X ∪ {#1, . . . , #i, $} Our languages are defined over the alphabet Bn: LΨ, L0Ψ ⊆ Bn∗. They are built by induction: for 0 ≤ i ≤ n we describe two languages Li, L0i ⊆ Bi∗ (starting with the case i = 0). The languages LΨ, L0Ψ are then defined as Ln, L0n. Construction of L0, L00. The language L0 is defined as L0 = (B0)∗. The language L00 is defined from the quantifier-free Boolean formula ϕ. Recall that by hypothesis ϕ is in conjunctive normal form: ϕ = Vj≤k ϕj were ϕi is a disjunction of literals. For all j ≤ k, we let Cj ⊆ B0 = X ∪ X as the following alphabet: Given x ∈ X, we have x ∈ Cj, if and only x is a literal in the disjunction ϕj. Given x ∈ X, we have x ∈ Cj, if and only ¬x is a literal in the disjunction ϕj. Finally, we define L00 = C1C2 · · · Ck. Construction of Li, L0i for i ≥ 1. We assume that Li−1, L0i−1 are defined and describe Li and L0i. We shall use the two following languages in the construction: Ti = (#ixi(Bi−1 \ {xi})∗$xi)∗ and Ti = (#ixi(Bi−1 \ {xi})∗$xi)∗ The definition of Li, L0i from Li−1, L0i−1 now depends on whether the quantifier Qi is existential or universal. If Qi is an existential quantifier (i.e. Qi = ∃): Li = (#i(xi + xi)Li−1$(xi + xi))∗#i L0 = (#i(xi + xi)L0i−1$(xi + xi))∗#i$ Ti#i + Ti#i i If the Qi is an universal quantifier (i.e. Qi = ∀): Li = (#i(xi + xi)Li−1$(xi + xi))∗#i L0i = Ti#i$(#i(xi + xi)L0i−1$(xi + xi))∗#i$Ti#i Finally, LΨ, L0Ψ are defined as the languages Ln, L0n ⊆ (Bn)∗. It is straightforward to verify from the definition, than given Ψ as input, one may compute NFAs for LΨ and L0Ψ in LogSpace. Consequently, it remains to prove that this construction is the desired reduction. We do so in the following proposition. I Proposition 20. For every quantified Boolean formula Ψ, Ψ is true if and only if LΨ is not ST[3/2]-separable from L0Ψ. Proposition 20 is proved by considering a stronger result which states properties of all the languages Li, L0i used in the construction of LΨ, L0Ψ (the argument is an induction on i). While we postpone the detailed proof to the full version of the paper, let us provide a sketch which presents this stronger result. Proof of Proposition 20 (sketch). Consider a quantified Boolean formula Ψ. Moreover, let B0, . . . , Bn and Li, L0i ⊆ (Bi)∗ as the alphabets and languages defined above. The key idea is to prove a property which makes sense for all languages Li, L0i. In the special case when i = n, this property implies Proposition 20. Consider 0 ≤ i ≤ n. We write Ψi for the sub-formula Ψi := Qi xi · · · Q1 x1 ϕ (with the free variables xi+1, . . . , xn). In particular, Ψ0 := ϕ and Ψn := Ψ. Moreover, we call “i-valuation” a sub-alphabet V ⊆ Bi such that, 1. #1, . . . , #i, $ ∈ V and x1, x1, . . . , xi, xi ∈ V , and, 2. for every j such that i < j ≤ n, one of the two following property holds: xj ∈ V and xj 6∈ V , or, xj 6∈ V and xj ∈ V . Clearly, an i-valuation corresponds to a truth assignment for all variables xj such that j > i (i.e. those that are free in Ψi): when the first (resp. second) assertion in Item 2 holds, xj is assigned to > (resp. ⊥). Hence, abusing terminology, we shall say that an i-valuation V satisfies Ψi if Ψi is true when replacing its free variables by the truth values provided by V . Finally, for 0 ≤ i ≤ n, if V ⊆ Bi is an i-valuation, we let [V ] ⊆ V ∗ as the following language. Given w ∈ V ∗, we have w ∈ [V ] if and only if for every j > i either xj ∈ alph(w) or xj ∈ alph(w) (by definition of i-valuations, exactly one of these two properties must hold). Proposition 20 is now a consequence of the following lemma. I Lemma 21. Consider 0 ≤ i ≤ n. Then given an i-valuation V , the two following properties are equivalent: 1. Ψi is satisfied by V . 2. Li ∩ [V ] is not ST[3/2]-separable from L0i ∩ [V ]. Lemma 21 is proved by induction on i using standard properties of the polynomial closure operation (see [18] for example). The proof is postponed to the full version of the paper. Let us explain why the lemma implies Proposition 20. Consider the special case of Lemma 21 when i = n. Observe that V = Bn is an n-valuation (the second assertion in the definition of n-valuations is trivially true since there are no j such that n < j ≤ n). Hence, since Ψ = Ψn and LΨ, L0Ψ = Ln, L0n, the lemma yields that, 1. Ψ is satisfied by V (i.e. Ψ is true). 2. LΨ ∩ [V ] is not ST[3/2]-separable from L0Ψ ∩ [V ]. Moreover, we have [V ] = (Bn)∗ by definition. Hence, we obtain that Ψ is true if and only if L is not ST[3/2]-separable from L0 which concludes the proof of Proposition 20. J 5.2 The level two For the level two, there is a gap between the lower and upper bound that we are able to prove. Specifically, we have the following theorem. I Theorem 22. ST[2]-separation is in EXPTime and PSpace-hard for both NFAs and monoids. Similarly to what happened with ST[3/2], the EXPTime upper bound is obtained by building on the techniques used in the previous section. Proving PSpace-hardness is achieved using a reduction from ST[3/2]-separation (which is PSpace-hard by Theorem 19). The reduction is much simpler than what we presented for ST[3/2] above. It is summarized by the following proposition. I Proposition 23. Consider an alphabet A and H, H0 ⊆ A∗. Let B = A ∪ {#, $} with #, $ 6∈ A, L = #(H0#(A∗$#)∗)∗H#(A∗$#)∗ ⊆ B∗ and L0 = #(H0#(A∗$#)∗)∗ ⊆ B∗. The two following properties are equivalent: 1. H is ST[3/2]-separable from H0. 2. L is ST[2]-separable from L0. Proposition 23 is proved using standard properties of the polynomial and Boolean closure operations. The argument is postponed ot the full version of the paper. It is clear than given as input NFAs for two languages H, H0, one may compute NFAs for the languages L, L0 defined Proposition 23 in LogSpace. Consequently, the proposition yields the desired LogSpace reduction from ST[3/2]-separation for NFAs to ST[2]-separation for NFAs. This proves that ST[2]-separation is PSpace-hard for NFAs (the result can then be lifted to monoids using Corollary 6) since ST[2] is a variety). 6 Conclusion We showed several results, all of them raising new questions. First we proved that for many important classes of languages (including all positive varieties), the complexity of separation does not depend on how the input languages are represented. A natural question is whether the technique can be adapted to encompass more classes. In particular, one may define more permissive notions of positive varieties by replacing closure under inverse image by weaker notions. For example, many natural classes are length increasing positive varieties: closure under inverse image only has to hold for length increasing morphisms (i.e., morphisms α : A∗ → B∗ such that |α(w)| ≥ |w| for every w ∈ A∗). For example, the levels of another famous concatenation hiearchy, the dot-depth [1] (whose basis is {∅, {ε}, A+, A∗}) are length increasing positive varieties. Can our techniques be adapted for such classes? Let us point out that there exists no example of natural class C for which separation is decidable and strictly harder for NFAs than for monoids. However, there are classes C for which the question is open (see for example the class of locally testable languages in [10]). We also investigated the complexity of separation for levels 1/2 and 1 in finitely based concatenation hierarchies. We showed that when the alphabet is fixed, the problems are respectively in NL and P for any such hierarchy. An interesting follow-up question would be to push these results to level 3/2, for which separation is also known to be decidable in any finitely based concatenation hierarchy [9]. A rough analysis of the techniques used in [9] suggests that this requires moving above P. Finally, we showed that in the famous Straubing-Thérien hierarchy, ST[3/2]-separation is PSpace-complete and ST[2]-separation is in EXPTime and PSpace-hard. Again, a natural question is to analyze ST[5/2]-separation whose decidability is established in [9]. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 22 Janusz A. Brzozowski and Rina S. Cohen. Dot-Depth of Star-Free Events . Journal of Computer and System Sciences , 5 ( 1 ): 1 - 16 , 1971 . Sang Cho and Dung T. Huynh . Finite automaton aperiodicity is PSPACE-complete . Theoretical Computer Science , 88 ( 1 ): 99 - 116 , 1991 . Wojciech Czerwiński , Wim Martens, and Tomáš Masopust . Efficient Separability of Regular Languages by Subsequences and Suffixes . In Proceedings of the 40th International Colloquium on Automata, Languages, and Programming (ICALP'13) , pages 150 - 161 . SpringerVerlag, 2013 . James Alexander Green . On the Structure of Semigroups. Annals of Mathematics , 54 ( 1 ): 163 - 172 , 1951 . Tomás Masopust . Separability by piecewise testable languages is PTIME-complete . Theoretical Computer Science , 711 : 109 - 114 , 2018 . Jean-Éric Pin . The Dot-Depth Hierarchy, 45 Years Later . In The Role of Theory in Computer Science - Essays Dedicated to Janusz Brzozowski, pages 177 - 202 , 2017 . Jean-Éric Pin . Mathematical Foundations of Automata Theory . In preparation, 2018 . URL: https://www.irif.fr/~jep/PDF/MPRI/MPRI.pdf. Jean-Eric Pin and Howard Straubing . Monoids of upper triangular Boolean matrices . In Semigroups. Structure and Universal Algebraic Problems , volume 39 of Colloquia Mathematica Societatis Janos Bolyal, pages 259 - 272 . North-Holland, 1985 . Thomas Place . Separating Regular Languages with Two Quantifier Alternations. Unpublished, a preliminary version can be found at https://arxiv.org/abs/1707.03295, 2018 . Thomas Place , Lorijn van Rooijen, and Marc Zeitoun . Separating Regular Languages by Locally Testable and Locally Threshold Testable Languages . In Proceedings of the 33rd IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science, FSTTCS'13 , pages 363 - 375 , Dagstuhl, Germany, 2013 . Schloss DagstuhlLeibniz-Zentrum fuer Informatik . Thomas Place , Lorijn van Rooijen, and Marc Zeitoun . Separating Regular Languages by Piecewise Testable and Unambiguous Languages . In Proceedings of the 38th International Symposium on Mathematical Foundations of Computer Science , MFCS' 13 , pages 729 - 740 . Springer-Verlag, 2013 . In Proceedings of the Joint Meeting of the 23rd EACSL Annual Conference on Computer Science Logic (CSL'14) and the 29th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS'14) , pages 75 : 1 - 75 : 10 . ACM, 2014 . Thomas Place and Marc Zeitoun . The tale of the quantifier alternation hierarchy of firstorder logic over words . SIGLOG News , 2 ( 3 ): 4 - 17 , 2015 . Logical Methods in Computer Science , 12 ( 1 ), 2016 . Thomas Place and Marc Zeitoun . Adding successor: A transfer theorem for separation and covering . Unpublished, a preliminary version can be found at http://arxiv.org/abs/ 1709.10052, 2017 . org/abs/1404.6832 , 2017 . Thomas Place and Marc Zeitoun . Separation for Dot-depth Two . In Proceedings of the 32th Annual ACM/IEEE Symposium on Logic in Computer Science , (LICS'17) , pages 202 - 213 . IEEE Computer Society , 2017 . Thomas Place and Marc Zeitoun . Generic results for concatenation hierarchies . Theory of Computing Systems (ToCS) , 2018 . Selected papers from CSR'17. Marcel Paul Schützenberger . On Finite Monoids Having Only Trivial Subgroups. Information and Control , 8 : 190 - 194 , 1965 . Imre Simon . Piecewise testable events . In 2nd GI Conference on Automata Theory and Formal Languages , pages 214 - 222 , 1975 . Theoretical Computer Science , 13 ( 2 ): 137 - 150 , 1981 . Denis Thérien . Classification of Finite Monoids: The Language Approach . Theoretical Computer Science, 14 ( 2 ): 195 - 208 , 1981 .


This is a preview of a remote PDF: http://drops.dagstuhl.de/opus/volltexte/2018/9946/pdf/LIPIcs-FSTTCS-2018-47.pdf

Thomas Place, Marc Zeitoun. The Complexity of Separation for Levels in Concatenation Hierarchies, LIPICS - Leibniz International Proceedings in Informatics, 2018, 47:1-47:17, DOI: 10.4230/LIPIcs.FSTTCS.2018.47