#### 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 .